Unify skill catalog database source

crates/aionui-ai-agent/src/capability/skill_manager/mod.rs

@@ -2,6 +2,7 @@ use std::collections::HashMap;
 use std::path::PathBuf;
 use std::sync::{Arc, LazyLock};
 
+use aionui_db::ISkillRepository;
 use regex::Regex;
 use tokio::sync::RwLock;
 use tracing::{debug, warn};
@@ -52,6 +53,9 @@ pub struct AcpSkillManager {
     /// Consumed by `discover_skills` / `get_skill` (Task 4 / 5 of the refactor).
     #[allow(dead_code)]
     paths: Arc<aionui_extension::SkillPaths>,
+    /// User skill state source. When absent, discovery falls back to legacy
+    /// path-based listing for unit tests that do not stand up a database.
+    skill_repo: Option<Arc<dyn ISkillRepository>>,
 }
 
 impl AcpSkillManager {
@@ -60,6 +64,16 @@ impl AcpSkillManager {
             cache: RwLock::new(HashMap::new()),
             discovered: RwLock::new(false),
             paths,
+            skill_repo: None,
+        })
+    }
+
+    pub fn new_with_repo(paths: Arc<aionui_extension::SkillPaths>, skill_repo: Arc<dyn ISkillRepository>) -> Arc<Self> {
+        Arc::new(Self {
+            cache: RwLock::new(HashMap::new()),
+            discovered: RwLock::new(false),
+            paths,
+            skill_repo: Some(skill_repo),
         })
     }
 
@@ -68,16 +82,17 @@ impl AcpSkillManager {
     /// Filtering rules:
     /// - Auto-inject builtin skills (under `auto-inject/` in the corpus) are
     ///   always included unless listed in `exclude_builtin_skills`.
-    /// - Opt-in builtin skills (siblings of `auto-inject/`) and custom/extension
-    ///   skills are included only if `enabled_skills` contains their name.
+    /// - Opt-in builtin skills (siblings of `auto-inject/`) and custom/cron/
+    ///   extension skills are included only if `enabled_skills` contains their
+    ///   name.
     ///
     /// Populates the cache; subsequent `get_skill(name)` calls read body lazily.
     pub async fn discover_skills(
         &self,
         enabled_skills: Option<&[String]>,
         exclude_builtin_skills: Option<&[String]>,
     ) -> Vec<SkillIndex> {
-        let items = match aionui_extension::list_available_skills(&self.paths).await {
+        let items = match self.list_available_skills().await {
             Ok(v) => v,
             Err(e) => {
                 warn!(error = %e, "Failed to list skills via extension service");
@@ -102,7 +117,9 @@ impl AcpSkillManager {
                         enabled_skills.is_some_and(|en| en.iter().any(|n| n == &item.name))
                     }
                 }
-                aionui_extension::SkillSource::Custom | aionui_extension::SkillSource::Extension => {
+                aionui_extension::SkillSource::Custom
+                | aionui_extension::SkillSource::Cron
+                | aionui_extension::SkillSource::Extension => {
                     enabled_skills.is_some_and(|en| en.iter().any(|n| n == &item.name))
                 }
             };
@@ -150,7 +167,7 @@ impl AcpSkillManager {
             *discovered = true;
             return Vec::new();
         }
-        let items = match aionui_extension::list_available_skills(&self.paths).await {
+        let items = match self.list_available_skills().await {
             Ok(v) => v,
             Err(e) => {
                 warn!(error = %e, "discover_by_names: list_available_skills failed");
@@ -188,6 +205,16 @@ impl AcpSkillManager {
             .collect()
     }
 
+    async fn list_available_skills(
+        &self,
+    ) -> Result<Vec<aionui_extension::SkillListItem>, aionui_extension::ExtensionError> {
+        if let Some(repo) = &self.skill_repo {
+            aionui_extension::list_available_skills_with_repo(&self.paths, repo.as_ref()).await
+        } else {
+            aionui_extension::list_available_skills(&self.paths).await
+        }
+    }
+
     /// Return the current skill index without re-scanning.
     pub async fn get_skills_index(&self) -> Vec<SkillIndex> {
         let cache = self.cache.read().await;
@@ -205,7 +232,7 @@ impl AcpSkillManager {
     /// Returns `None` if the skill is unknown. On first access the body is
     /// read via the appropriate channel based on `source`:
     /// - `Builtin` → `aionui_extension::read_builtin_skill(&paths, relative)`
-    /// - `Custom` / `Extension` → direct `tokio::fs::read_to_string(location/SKILL.md)`
+    /// - `Custom` / `Cron` / `Extension` → direct `tokio::fs::read_to_string(location/SKILL.md)`
     pub async fn get_skill(&self, name: &str) -> Option<SkillDefinition> {
         // Fast path: check if body is already cached
         {
@@ -239,7 +266,9 @@ impl AcpSkillManager {
                     String::new()
                 }
             }
-            aionui_extension::SkillSource::Custom | aionui_extension::SkillSource::Extension => {
+            aionui_extension::SkillSource::Custom
+            | aionui_extension::SkillSource::Cron
+            | aionui_extension::SkillSource::Extension => {
                 // `location` for scanned user skills is the directory; append SKILL.md.
                 let skill_file = if def.location.is_dir() {
                     def.location.join("SKILL.md")

crates/aionui-api-types/src/lib.rs

@@ -140,12 +140,13 @@ pub use shell::{
     SpeechToTextProvider, SpeechToTextResult, SttStreamClientMessage, SttStreamServerMessage, ToolType,
 };
 pub use skill::{
-    AddExternalPathRequest, BuiltinAutoSkillResponse, DeleteSkillRequest, ExportSkillRequest,
-    ExternalSkillSourceResponse, ImportSkillRequest, ImportSkillResponse, MaterializeSkillsRequest,
+    AddExternalPathRequest, DeleteSkillRequest, ExportSkillRequest, ExternalSkillSourceResponse,
+    ImportSkillFailureResponse, ImportSkillRequest, ImportSkillResponse, MaterializeSkillsRequest,
     MaterializeSkillsResponse, MaterializedSkillRef, NamedPathResponse, ReadAssistantRuleRequest,
     ReadBuiltinResourceRequest, ReadSkillInfoRequest, ReadSkillInfoResponse, RemoveExternalPathRequest,
-    ScanForSkillsRequest, ScanForSkillsResponse, ScannedSkillResponse, SkillListItemResponse, SkillPathsResponse,
-    SkillSourceResponse, WriteAssistantRuleRequest,
+    ScanForSkillsRequest, ScanForSkillsResponse, ScannedSkillResponse, SkillImportLimitsResponse,
+    SkillImportRecordResponse, SkillListItemResponse, SkillPathsResponse, SkillSourceResponse,
+    WriteAssistantRuleRequest,
 };
 pub use system::{
     ClientPreferencesResponse, SystemSettingsResponse, UpdateClientPreferencesRequest, UpdateSettingsRequest,

crates/aionui-api-types/src/skill.rs

@@ -4,7 +4,7 @@ use serde::{Deserialize, Serialize};
 // A. Skill list & info
 // ---------------------------------------------------------------------------
 
-/// Origin of a listed skill — `builtin`, `custom`, or `extension`.
+/// Origin of a listed skill — `builtin`, `custom`, `cron`, or `extension`.
 ///
 /// Matches the renderer contract in
 /// `src/common/adapter/ipcBridge.ts::listAvailableSkills`.
@@ -13,6 +13,7 @@ use serde::{Deserialize, Serialize};
 pub enum SkillSourceResponse {
     Builtin,
     Custom,
+    Cron,
     Extension,
 }
 
@@ -35,17 +36,6 @@ pub struct SkillListItemResponse {
     pub source: SkillSourceResponse,
 }
 
-/// An auto-injected built-in skill (`GET /api/skills/builtin-auto`).
-///
-/// `location` is the relative path the frontend passes back into
-/// `POST /api/skills/builtin-skill` (e.g. `"auto-inject/cron/SKILL.md"`).
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-pub struct BuiltinAutoSkillResponse {
-    pub name: String,
-    pub description: String,
-    pub location: String,
-}
-
 /// Request body for `POST /api/skills/info`.
 #[derive(Debug, Clone, Deserialize)]
 pub struct ReadSkillInfoRequest {
@@ -75,6 +65,54 @@ pub struct ImportSkillResponse {
     pub skill_name: String,
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub skill_names: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub failed: Vec<ImportSkillFailureResponse>,
+}
+
+/// Per-skill failure summary for batch skill import operations.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct ImportSkillFailureResponse {
+    pub source_name: String,
+    pub code: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error_path: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub actual_bytes: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub limit_bytes: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub line: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub column: Option<i64>,
+}
+
+/// One row in the skill import history.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct SkillImportRecordResponse {
+    pub id: String,
+    pub operation_id: String,
+    pub source_label: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub source_path: Option<String>,
+    pub source_name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub skill_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub skill_name: Option<String>,
+    pub status: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error_code: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error_path: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub actual_bytes: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub limit_bytes: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub line: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub column: Option<i64>,
+    pub created_at: i64,
 }
 
 /// Request body for `POST /api/skills/export-symlink`.
@@ -143,6 +181,13 @@ pub struct SkillPathsResponse {
     pub builtin_skills_dir: String,
 }
 
+/// Response for `GET /api/skills/import-limits`.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct SkillImportLimitsResponse {
+    pub max_file_bytes: u64,
+    pub max_total_bytes: u64,
+}
+
 // ---------------------------------------------------------------------------
 // D. Assistant rules & skills
 // ---------------------------------------------------------------------------
@@ -366,6 +411,10 @@ mod tests {
             serde_json::to_value(SkillSourceResponse::Custom).unwrap(),
             serde_json::json!("custom")
         );
+        assert_eq!(
+            serde_json::to_value(SkillSourceResponse::Cron).unwrap(),
+            serde_json::json!("cron")
+        );
         assert_eq!(
             serde_json::to_value(SkillSourceResponse::Extension).unwrap(),
             serde_json::json!("extension")
@@ -408,10 +457,29 @@ mod tests {
         let resp = ImportSkillResponse {
             skill_name: "imported-skill".into(),
             skill_names: vec!["imported-skill".into(), "second-skill".into()],
+            failed: vec![ImportSkillFailureResponse {
+                source_name: "bad-skill".into(),
+                code: "SKILL_IMPORT_FILE_TOO_LARGE".into(),
+                error_path: Some("assets/movie.mp4".into()),
+                actual_bytes: Some(20),
+                limit_bytes: Some(10),
+                line: None,
+                column: None,
+            }],
         };
         let json = serde_json::to_value(&resp).unwrap();
         assert_eq!(json["skill_name"], "imported-skill");
         assert_eq!(json["skill_names"], json!(["imported-skill", "second-skill"]));
+        assert_eq!(
+            json["failed"],
+            json!([{
+                "source_name": "bad-skill",
+                "code": "SKILL_IMPORT_FILE_TOO_LARGE",
+                "error_path": "assets/movie.mp4",
+                "actual_bytes": 20,
+                "limit_bytes": 10
+            }])
+        );
         assert!(json.get("skillName").is_none());
     }
 

crates/aionui-app/assets/builtin-skills/aionui-config/SKILL.md

@@ -217,8 +217,8 @@ python3 scripts/aionui_api.py get /api/skills/paths
 ### Import a skill into the registry
 
 `POST /api/skills/import` copies a skill folder into the user skills dir and
-registers it. `import-symlink` links it instead (good for skills you keep editing
-in an external repo).
+registers it. It also accepts a parent folder containing multiple skills or a
+zip package.
 
 ```bash
 python3 scripts/aionui_api.py post /api/skills/import '{"skill_path":"/abs/path/to/skill-folder"}'

crates/aionui-app/src/router/routes.rs

@@ -23,6 +23,7 @@ use aionui_auth::{
 use aionui_channel::channel_routes;
 #[cfg(feature = "weixin")]
 use aionui_channel::weixin_login_route;
+use aionui_common::ApiErrorLogContext;
 use aionui_conversation::{conversation_ops_routes, conversation_routes};
 use aionui_cron::cron_routes;
 use aionui_extension::{extension_routes, hub_routes, skill_routes};
@@ -312,6 +313,10 @@ async fn normalize_boundary_error_response(request: Request, next: Next) -> Resp
 
     let original_headers = response.headers().clone();
     let mut normalized = (status, Json(ErrorResponse::new(error, code))).into_response();
+    normalized.extensions_mut().insert(ApiErrorLogContext {
+        code,
+        message: error.to_owned(),
+    });
     for (name, value) in original_headers.iter() {
         if *name != header::CONTENT_TYPE && *name != header::CONTENT_LENGTH {
             normalized.headers_mut().insert(name, value.clone());

crates/aionui-app/src/router/state.rs

@@ -510,6 +510,7 @@ pub async fn build_channel_state(
     );
     let skill_resolver = Arc::new(aionui_conversation::skill_resolver::ExtensionSkillResolver::new(
         services.skill_paths.clone(),
+        services.skill_repo.clone(),
     ));
     let agent_metadata_repo: Arc<dyn aionui_db::IAgentMetadataRepository> = Arc::new(
         aionui_db::SqliteAgentMetadataRepository::new(services.database.pool().clone()),
@@ -639,6 +640,7 @@ pub fn build_cron_state(services: &AppServices) -> CronRouterState {
     let acp_session_repo: Arc<dyn IAcpSessionRepository> = Arc::new(SqliteAcpSessionRepository::new(pool));
     let skill_resolver = Arc::new(aionui_conversation::skill_resolver::ExtensionSkillResolver::new(
         services.skill_paths.clone(),
+        services.skill_repo.clone(),
     ));
     let conv_service = ConversationService::new(
         services.work_dir.clone(),
@@ -766,13 +768,6 @@ pub async fn build_extension_states(
     let index_manager = HubIndexManager::new(hub_dir, registry.clone());
     let installer = HubInstaller::new(index_manager.clone(), registry.clone());
 
-    let app_resource_dir = std::env::current_exe()
-        .ok()
-        .and_then(|p| p.canonicalize().ok())
-        .and_then(|p| p.parent().map(|pp| pp.to_path_buf()))
-        .unwrap_or_else(|| std::path::PathBuf::from("."));
-    let skill_paths = aionui_extension::resolve_skill_paths(&app_resource_dir, &skill_data_dir);
-
     let ext_paths_mgr = Arc::new(ExternalPathsManager::new(&skill_data_dir).await);
 
     let ext_state = ExtensionRouterState {
@@ -785,7 +780,8 @@ pub async fn build_extension_states(
     };
 
     let skill_state = SkillRouterState {
-        skill_paths,
+        skill_paths: services.skill_paths.as_ref().clone(),
+        skill_repo: services.skill_repo.clone(),
         external_paths_manager: ext_paths_mgr,
         assistant_dispatcher: None,
     };