wuxu/codeg
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chore(lint): clean up frontend and Rust lint issues

Browse Source
This commit is contained in:
xintaofei
2026-04-23 15:56:41 +08:00
parent 1dd40d0baf
commit 022172a9ea
69 changed files with 1138 additions and 1248 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src-tauri/src/web/auth.rs
View File

@@ -5,11 +5,7 @@ use axum::{
response::{IntoResponse, Response},
};
pub async fn require_token(
request: Request,
next: Next,
token: String,
) -> Response {
pub async fn require_token(request: Request, next: Next, token: String) -> Response {
// Allow WebSocket upgrade requests to authenticate via query param.
// The token value is URL-encoded by the client, so decode before comparing.
if let Some(query) = request.uri().query() {

6
src-tauri/src/web/event_bridge.rs
View File

@@ -56,11 +56,7 @@ pub enum EventEmitter {
}
/// Unified event emission: sends to both Tauri webview and Web clients (if applicable).
pub fn emit_event(
emitter: &EventEmitter,
event: &str,
payload: impl Serialize + Clone,
) {
pub fn emit_event(emitter: &EventEmitter, event: &str, payload: impl Serialize + Clone) {
match emitter {
#[cfg(feature = "tauri-runtime")]
EventEmitter::Tauri(app) => {

23
src-tauri/src/web/handlers/acp.rs
View File

@@ -188,10 +188,9 @@ pub struct AcpListAgentSkillsParams {
pub async fn acp_list_agent_skills(
Json(params): Json<AcpListAgentSkillsParams>,
) -> Result<Json<AgentSkillsListResult>, AppCommandError> {
let result =
acp_commands::acp_list_agent_skills(params.agent_type, params.workspace_path)
.await
.map_err(|e| AppCommandError::task_execution_failed(e.to_string()))?;
let result = acp_commands::acp_list_agent_skills(params.agent_type, params.workspace_path)
.await
.map_err(|e| AppCommandError::task_execution_failed(e.to_string()))?;
Ok(Json(result))
}
@@ -482,10 +481,9 @@ pub async fn acp_detect_agent_local_version(
Json(params): Json<AgentTypeParams>,
) -> Result<Json<Option<String>>, AppCommandError> {
let db = &state.db;
let result =
acp_commands::acp_detect_agent_local_version_core(params.agent_type, &db.conn)
.await
.map_err(|e| AppCommandError::task_execution_failed(e.to_string()))?;
let result = acp_commands::acp_detect_agent_local_version_core(params.agent_type, &db.conn)
.await
.map_err(|e| AppCommandError::task_execution_failed(e.to_string()))?;
Ok(Json(result))
}
@@ -610,11 +608,8 @@ pub struct CodexPollDeviceCodeParams {
pub async fn codex_poll_device_code(
Json(params): Json<CodexPollDeviceCodeParams>,
) -> Result<Json<acp_commands::CodexDeviceCodePollResult>, AppCommandError> {
let result = acp_commands::codex_poll_device_code_core(
params.device_auth_id,
params.user_code,
)
.await
.map_err(|e| AppCommandError::task_execution_failed(e.to_string()))?;
let result = acp_commands::codex_poll_device_code_core(params.device_auth_id, params.user_code)
.await
.map_err(|e| AppCommandError::task_execution_failed(e.to_string()))?;
Ok(Json(result))
}

8
src-tauri/src/web/handlers/chat_channel.rs
View File

@@ -5,8 +5,8 @@ use serde::Deserialize;
use crate::app_error::AppCommandError;
use crate::app_state::AppState;
use crate::commands::chat_channel as cc_commands;
use crate::chat_channel::backends::weixin::{WeixinQrcodeInfo, WeixinQrcodeStatusPublic};
use crate::commands::chat_channel as cc_commands;
use crate::models::chat_channel::{ChannelStatusInfo, ChatChannelInfo, ChatChannelMessageLogInfo};
// ---------------------------------------------------------------------------
@@ -167,8 +167,7 @@ pub async fn test_chat_channel(
pub async fn get_chat_channel_status(
Extension(state): Extension<Arc<AppState>>,
) -> Result<Json<Vec<ChannelStatusInfo>>, AppCommandError> {
let result =
cc_commands::get_chat_channel_status_core(&state.chat_channel_manager).await?;
let result = cc_commands::get_chat_channel_status_core(&state.chat_channel_manager).await?;
Ok(Json(result))
}
@@ -270,7 +269,6 @@ pub async fn weixin_check_qrcode(
Json(params): Json<WeixinCheckQrcodeParams>,
) -> Result<Json<WeixinQrcodeStatusPublic>, AppCommandError> {
let result =
cc_commands::weixin_check_qrcode_core(&state.db, params.channel_id, &params.qrcode)
.await?;
cc_commands::weixin_check_qrcode_core(&state.db, params.channel_id, &params.qrcode).await?;
Ok(Json(result))
}

12
src-tauri/src/web/handlers/conversations.rs
View File

@@ -98,8 +98,7 @@ pub struct GetConversationParams {
pub async fn get_conversation(
Json(params): Json<GetConversationParams>,
) -> Result<Json<ConversationDetail>, AppCommandError> {
let result =
conv_commands::get_conversation(params.agent_type, params.conversation_id).await?;
let result = conv_commands::get_conversation(params.agent_type, params.conversation_id).await?;
Ok(Json(result))
}
@@ -149,9 +148,10 @@ pub async fn import_local_conversations(
.await
.map_err(AppCommandError::from)?
.ok_or_else(|| AppCommandError::not_found("Folder not found"))?;
let result = import_service::import_local_conversations(&db.conn, params.folder_id, &folder.path)
.await
.map_err(AppCommandError::from)?;
let result =
import_service::import_local_conversations(&db.conn, params.folder_id, &folder.path)
.await
.map_err(AppCommandError::from)?;
Ok(Json(result))
}
@@ -251,4 +251,4 @@ pub async fn update_conversation_external_id(
.await
.map_err(AppCommandError::from)?;
Ok(Json(()))
}
}

26
src-tauri/src/web/handlers/files.rs
View File

@@ -77,24 +77,21 @@ pub struct CreateFileTreeEntryParams {
pub async fn read_file_preview(
Json(params): Json<ReadFilePreviewParams>,
) -> Result<Json<folder_commands::FilePreviewContent>, AppCommandError> {
let result =
folder_commands::read_file_preview(params.root_path, params.path).await?;
let result = folder_commands::read_file_preview(params.root_path, params.path).await?;
Ok(Json(result))
}
pub async fn read_file_base64(
Json(params): Json<ReadFileBase64Params>,
) -> Result<Json<String>, AppCommandError> {
let result =
folder_commands::read_file_base64(params.path, params.max_bytes).await?;
let result = folder_commands::read_file_base64(params.path, params.max_bytes).await?;
Ok(Json(result))
}
pub async fn read_file_for_edit(
Json(params): Json<ReadFileForEditParams>,
) -> Result<Json<folder_commands::FileEditContent>, AppCommandError> {
let result =
folder_commands::read_file_for_edit(params.root_path, params.path).await?;
let result = folder_commands::read_file_for_edit(params.root_path, params.path).await?;
Ok(Json(result))
}
@@ -114,24 +111,17 @@ pub async fn save_file_content(
pub async fn save_file_copy(
Json(params): Json<SaveFileCopyParams>,
) -> Result<Json<folder_commands::FileSaveResult>, AppCommandError> {
let result = folder_commands::save_file_copy(
params.root_path,
params.path,
params.content,
)
.await?;
let result =
folder_commands::save_file_copy(params.root_path, params.path, params.content).await?;
Ok(Json(result))
}
pub async fn rename_file_tree_entry(
Json(params): Json<RenameFileTreeEntryParams>,
) -> Result<Json<String>, AppCommandError> {
let result = folder_commands::rename_file_tree_entry(
params.root_path,
params.path,
params.new_name,
)
.await?;
let result =
folder_commands::rename_file_tree_entry(params.root_path, params.path, params.new_name)
.await?;
Ok(Json(result))
}

22
src-tauri/src/web/handlers/folder_commands.rs
View File

@@ -68,14 +68,10 @@ pub async fn create_folder_command(
Json(params): Json<CreateFolderCommandParams>,
) -> Result<Json<FolderCommandInfo>, AppCommandError> {
let db = &state.db;
let result = folder_command_service::create(
&db.conn,
params.folder_id,
&params.name,
&params.command,
)
.await
.map_err(AppCommandError::from)?;
let result =
folder_command_service::create(&db.conn, params.folder_id, &params.name, &params.command)
.await
.map_err(AppCommandError::from)?;
Ok(Json(result))
}
@@ -142,10 +138,12 @@ pub async fn bootstrap_folder_commands_from_package_json(
crate::commands::folder_commands::load_package_scripts_as_commands(&params.folder_path)
})
.await
.map_err(|e| AppCommandError::new(
crate::app_error::AppErrorCode::TaskExecutionFailed,
format!("bootstrap task failed: {e}"),
))?;
.map_err(|e| {
AppCommandError::new(
crate::app_error::AppErrorCode::TaskExecutionFailed,
format!("bootstrap task failed: {e}"),
)
})?;
if commands_to_create.is_empty() {
return Ok(Json(existing));

92
src-tauri/src/web/handlers/git.rs
View File

@@ -79,8 +79,7 @@ pub struct GitStatusParams {
pub async fn git_status(
Json(params): Json<GitStatusParams>,
) -> Result<Json<Vec<folder_commands::GitStatusEntry>>, AppCommandError> {
let result =
folder_commands::git_status(params.path, params.show_all_untracked).await?;
let result = folder_commands::git_status(params.path, params.show_all_untracked).await?;
Ok(Json(result))
}
@@ -101,8 +100,7 @@ pub struct GitCommitBranchesParams {
pub async fn git_commit_branches(
Json(params): Json<GitCommitBranchesParams>,
) -> Result<Json<Vec<String>>, AppCommandError> {
let result =
folder_commands::git_commit_branches(params.path, params.commit).await?;
let result = folder_commands::git_commit_branches(params.path, params.commit).await?;
Ok(Json(result))
}
@@ -117,9 +115,7 @@ pub struct GitShowFileParams {
pub async fn git_show_file(
Json(params): Json<GitShowFileParams>,
) -> Result<Json<String>, AppCommandError> {
let result =
folder_commands::git_show_file(params.path, params.file, params.ref_name)
.await?;
let result = folder_commands::git_show_file(params.path, params.file, params.ref_name).await?;
Ok(Json(result))
}
@@ -130,9 +126,7 @@ pub struct GitDiffParams {
pub file: Option<String>,
}
pub async fn git_diff(
Json(params): Json<GitDiffParams>,
) -> Result<Json<String>, AppCommandError> {
pub async fn git_diff(Json(params): Json<GitDiffParams>) -> Result<Json<String>, AppCommandError> {
let result = folder_commands::git_diff(params.path, params.file).await?;
Ok(Json(result))
}
@@ -160,13 +154,8 @@ pub struct GitLogParams {
pub async fn git_log(
Json(params): Json<GitLogParams>,
) -> Result<Json<folder_commands::GitLogResult>, AppCommandError> {
let result = folder_commands::git_log(
params.path,
params.limit,
params.branch,
params.remote,
)
.await?;
let result =
folder_commands::git_log(params.path, params.limit, params.branch, params.remote).await?;
Ok(Json(result))
}
@@ -174,9 +163,7 @@ pub async fn git_log(
// New pure git handlers (Pattern A – direct function calls)
// ---------------------------------------------------------------------------
pub async fn git_init(
Json(params): Json<PathParams>,
) -> Result<Json<()>, AppCommandError> {
pub async fn git_init(Json(params): Json<PathParams>) -> Result<Json<()>, AppCommandError> {
folder_commands::git_init(params.path).await?;
Ok(Json(()))
}
@@ -220,8 +207,7 @@ pub struct GitNewBranchParams {
pub async fn git_new_branch(
Json(params): Json<GitNewBranchParams>,
) -> Result<Json<()>, AppCommandError> {
folder_commands::git_new_branch(params.path, params.branch_name, params.start_point)
.await?;
folder_commands::git_new_branch(params.path, params.branch_name, params.start_point).await?;
Ok(Json(()))
}
@@ -236,12 +222,8 @@ pub struct GitWorktreeAddParams {
pub async fn git_worktree_add(
Json(params): Json<GitWorktreeAddParams>,
) -> Result<Json<()>, AppCommandError> {
folder_commands::git_worktree_add(
params.path,
params.branch_name,
params.worktree_path,
)
.await?;
folder_commands::git_worktree_add(params.path, params.branch_name, params.worktree_path)
.await?;
Ok(Json(()))
}
@@ -260,9 +242,7 @@ pub struct GitResetParams {
pub mode: String,
}
pub async fn git_reset(
Json(params): Json<GitResetParams>,
) -> Result<Json<()>, AppCommandError> {
pub async fn git_reset(Json(params): Json<GitResetParams>) -> Result<Json<()>, AppCommandError> {
folder_commands::git_reset(params.path, params.commit, params.mode).await?;
Ok(Json(()))
}
@@ -285,12 +265,8 @@ pub struct GitStashPushParams {
pub async fn git_stash_push(
Json(params): Json<GitStashPushParams>,
) -> Result<Json<String>, AppCommandError> {
let result = folder_commands::git_stash_push(
params.path,
params.message,
params.keep_index,
)
.await?;
let result =
folder_commands::git_stash_push(params.path, params.message, params.keep_index).await?;
Ok(Json(result))
}
@@ -304,8 +280,7 @@ pub struct GitStashPopParams {
pub async fn git_stash_pop(
Json(params): Json<GitStashPopParams>,
) -> Result<Json<String>, AppCommandError> {
let result =
folder_commands::git_stash_pop(params.path, params.stash_ref).await?;
let result = folder_commands::git_stash_pop(params.path, params.stash_ref).await?;
Ok(Json(result))
}
@@ -319,16 +294,14 @@ pub async fn git_stash_list(
pub async fn git_stash_apply(
Json(params): Json<PathStashRefParams>,
) -> Result<Json<String>, AppCommandError> {
let result =
folder_commands::git_stash_apply(params.path, params.stash_ref).await?;
let result = folder_commands::git_stash_apply(params.path, params.stash_ref).await?;
Ok(Json(result))
}
pub async fn git_stash_drop(
Json(params): Json<PathStashRefParams>,
) -> Result<Json<String>, AppCommandError> {
let result =
folder_commands::git_stash_drop(params.path, params.stash_ref).await?;
let result = folder_commands::git_stash_drop(params.path, params.stash_ref).await?;
Ok(Json(result))
}
@@ -342,16 +315,14 @@ pub async fn git_stash_clear(
pub async fn git_stash_show(
Json(params): Json<PathStashRefParams>,
) -> Result<Json<Vec<folder_commands::GitStatusEntry>>, AppCommandError> {
let result =
folder_commands::git_stash_show(params.path, params.stash_ref).await?;
let result = folder_commands::git_stash_show(params.path, params.stash_ref).await?;
Ok(Json(result))
}
pub async fn git_is_tracked(
Json(params): Json<PathFileParams>,
) -> Result<Json<bool>, AppCommandError> {
let result =
folder_commands::git_is_tracked(params.path, params.file).await?;
let result = folder_commands::git_is_tracked(params.path, params.file).await?;
Ok(Json(result))
}
@@ -366,12 +337,8 @@ pub struct GitDiffWithBranchParams {
pub async fn git_diff_with_branch(
Json(params): Json<GitDiffWithBranchParams>,
) -> Result<Json<String>, AppCommandError> {
let result = folder_commands::git_diff_with_branch(
params.path,
params.branch,
params.file,
)
.await?;
let result =
folder_commands::git_diff_with_branch(params.path, params.branch, params.file).await?;
Ok(Json(result))
}
@@ -386,9 +353,7 @@ pub struct GitShowDiffParams {
pub async fn git_show_diff(
Json(params): Json<GitShowDiffParams>,
) -> Result<Json<String>, AppCommandError> {
let result =
folder_commands::git_show_diff(params.path, params.commit, params.file)
.await?;
let result = folder_commands::git_show_diff(params.path, params.commit, params.file).await?;
Ok(Json(result))
}
@@ -437,16 +402,14 @@ pub async fn git_set_remote_url(
pub async fn git_merge(
Json(params): Json<PathBranchParams>,
) -> Result<Json<folder_commands::GitMergeResult>, AppCommandError> {
let result =
folder_commands::git_merge(params.path, params.branch_name).await?;
let result = folder_commands::git_merge(params.path, params.branch_name).await?;
Ok(Json(result))
}
pub async fn git_rebase(
Json(params): Json<PathBranchParams>,
) -> Result<Json<folder_commands::GitRebaseResult>, AppCommandError> {
let result =
folder_commands::git_rebase(params.path, params.branch_name).await?;
let result = folder_commands::git_rebase(params.path, params.branch_name).await?;
Ok(Json(result))
}
@@ -462,8 +425,7 @@ pub async fn git_delete_branch(
Json(params): Json<GitDeleteBranchParams>,
) -> Result<Json<String>, AppCommandError> {
let result =
folder_commands::git_delete_branch(params.path, params.branch_name, params.force)
.await?;
folder_commands::git_delete_branch(params.path, params.branch_name, params.force).await?;
Ok(Json(result))
}
@@ -503,16 +465,14 @@ pub async fn git_list_conflicts(
pub async fn git_conflict_file_versions(
Json(params): Json<PathFileParams>,
) -> Result<Json<folder_commands::GitConflictFileVersions>, AppCommandError> {
let result =
folder_commands::git_conflict_file_versions(params.path, params.file).await?;
let result = folder_commands::git_conflict_file_versions(params.path, params.file).await?;
Ok(Json(result))
}
pub async fn git_resolve_conflict(
Json(params): Json<PathFileContentParams>,
) -> Result<Json<()>, AppCommandError> {
folder_commands::git_resolve_conflict(params.path, params.file, params.content)
.await?;
folder_commands::git_resolve_conflict(params.path, params.file, params.content).await?;
Ok(Json(()))
}

34
src-tauri/src/web/handlers/mcp.rs
View File

@@ -71,8 +71,7 @@ pub async fn mcp_scan_local() -> Result<Json<Vec<LocalMcpServer>>, AppCommandErr
Ok(Json(result))
}
pub async fn mcp_list_marketplaces(
) -> Result<Json<Vec<McpMarketplaceProvider>>, AppCommandError> {
pub async fn mcp_list_marketplaces() -> Result<Json<Vec<McpMarketplaceProvider>>, AppCommandError> {
let result = mcp_commands::mcp_list_marketplaces().await?;
Ok(Json(result))
}
@@ -80,23 +79,18 @@ pub async fn mcp_list_marketplaces(
pub async fn mcp_search_marketplace(
Json(params): Json<SearchMarketplaceParams>,
) -> Result<Json<Vec<McpMarketplaceItem>>, AppCommandError> {
let result = mcp_commands::mcp_search_marketplace(
params.provider_id,
params.query,
params.limit,
)
.await?;
let result =
mcp_commands::mcp_search_marketplace(params.provider_id, params.query, params.limit)
.await?;
Ok(Json(result))
}
pub async fn mcp_get_marketplace_server_detail(
Json(params): Json<GetMarketplaceServerDetailParams>,
) -> Result<Json<McpMarketplaceServerDetail>, AppCommandError> {
let result = mcp_commands::mcp_get_marketplace_server_detail(
params.provider_id,
params.server_id,
)
.await?;
let result =
mcp_commands::mcp_get_marketplace_server_detail(params.provider_id, params.server_id)
.await?;
Ok(Json(result))
}
@@ -119,27 +113,21 @@ pub async fn mcp_install_from_marketplace(
pub async fn mcp_upsert_local_server(
Json(params): Json<UpsertLocalServerParams>,
) -> Result<Json<LocalMcpServer>, AppCommandError> {
let result = mcp_commands::mcp_upsert_local_server(
params.server_id,
params.spec,
params.apps,
)
.await?;
let result =
mcp_commands::mcp_upsert_local_server(params.server_id, params.spec, params.apps).await?;
Ok(Json(result))
}
pub async fn mcp_set_server_apps(
Json(params): Json<SetServerAppsParams>,
) -> Result<Json<Option<LocalMcpServer>>, AppCommandError> {
let result =
mcp_commands::mcp_set_server_apps(params.server_id, params.apps).await?;
let result = mcp_commands::mcp_set_server_apps(params.server_id, params.apps).await?;
Ok(Json(result))
}
pub async fn mcp_remove_server(
Json(params): Json<RemoveServerParams>,
) -> Result<Json<bool>, AppCommandError> {
let result =
mcp_commands::mcp_remove_server(params.server_id, params.apps).await?;
let result = mcp_commands::mcp_remove_server(params.server_id, params.apps).await?;
Ok(Json(result))
}

23
src-tauri/src/web/handlers/system_settings.rs
View File

@@ -44,8 +44,7 @@ pub async fn get_system_language_settings(
Extension(state): Extension<Arc<AppState>>,
) -> Result<Json<SystemLanguageSettings>, AppCommandError> {
let db = &state.db;
let settings =
settings_commands::load_system_language_settings(&db.conn).await?;
let settings = settings_commands::load_system_language_settings(&db.conn).await?;
Ok(Json(settings))
}
@@ -67,13 +66,9 @@ pub async fn update_system_proxy_settings(
.with_detail(e.to_string())
})?;
app_metadata_service::upsert_value(
&db.conn,
SYSTEM_PROXY_SETTINGS_KEY,
&serialized,
)
.await
.map_err(AppCommandError::from)?;
app_metadata_service::upsert_value(&db.conn, SYSTEM_PROXY_SETTINGS_KEY, &serialized)
.await
.map_err(AppCommandError::from)?;
proxy::apply_system_proxy_settings(&settings)?;
Ok(Json(settings))
@@ -91,13 +86,9 @@ pub async fn update_system_language_settings(
.with_detail(e.to_string())
})?;
app_metadata_service::upsert_value(
&db.conn,
SYSTEM_LANGUAGE_SETTINGS_KEY,
&serialized,
)
.await
.map_err(AppCommandError::from)?;
app_metadata_service::upsert_value(&db.conn, SYSTEM_LANGUAGE_SETTINGS_KEY, &serialized)
.await
.map_err(AppCommandError::from)?;
crate::web::event_bridge::emit_event(
&state.emitter,

9
src-tauri/src/web/handlers/version_control.rs
View File

@@ -125,10 +125,8 @@ pub async fn get_github_accounts(
let settings = match raw {
Some(raw) => serde_json::from_str::<GitHubAccountsSettings>(&raw).map_err(|e| {
AppCommandError::configuration_invalid(
"Failed to parse stored GitHub accounts",
)
.with_detail(e.to_string())
AppCommandError::configuration_invalid("Failed to parse stored GitHub accounts")
.with_detail(e.to_string())
})?,
None => GitHubAccountsSettings::default(),
};
@@ -160,8 +158,7 @@ pub async fn update_github_accounts(
pub async fn validate_github_token(
Json(params): Json<ValidateGitHubTokenParams>,
) -> Result<Json<GitHubTokenValidation>, AppCommandError> {
let result =
vc_commands::validate_github_token(params.server_url, params.token).await?;
let result = vc_commands::validate_github_token(params.server_url, params.token).await?;
Ok(Json(result))
}

60
src-tauri/src/web/mod.rs
View File

@@ -121,11 +121,10 @@ async fn persist_web_service_config(
})
.await
.map_err(|e: TransactionError<AppCommandError>| match e {
TransactionError::Connection(db) => AppCommandError::new(
AppErrorCode::DatabaseError,
"Database transaction failed",
)
.with_detail(db.to_string()),
TransactionError::Connection(db) => {
AppCommandError::new(AppErrorCode::DatabaseError, "Database transaction failed")
.with_detail(db.to_string())
}
TransactionError::Transaction(inner) => inner,
})
}
@@ -178,12 +177,18 @@ pub(crate) fn find_static_dir_tauri(app: &tauri::AppHandle) -> PathBuf {
if let Some(ref dir) = resource {
let web = dir.join("web");
if web.join("index.html").exists() {
eprintln!("[WEB] Serving static files from resource/web: {}", web.display());
eprintln!(
"[WEB] Serving static files from resource/web: {}",
web.display()
);
return web;
}
// Fallback: files at resource root.
if dir.join("index.html").exists() {
eprintln!("[WEB] Serving static files from resource dir: {}", dir.display());
eprintln!(
"[WEB] Serving static files from resource dir: {}",
dir.display()
);
return dir.clone();
}
}
@@ -197,7 +202,10 @@ pub(crate) fn find_static_dir_fallback() -> PathBuf {
let project_out = manifest_dir.parent().map(|p| p.join("out"));
if let Some(ref out) = project_out {
if out.join("index.html").exists() {
eprintln!("[WEB] Serving static files from project out/: {}", out.display());
eprintln!(
"[WEB] Serving static files from project out/: {}",
out.display()
);
return out.clone();
}
}
@@ -217,7 +225,10 @@ pub fn find_static_dir_standalone(explicit: Option<&str>) -> PathBuf {
if let Some(dir) = explicit {
let p = PathBuf::from(dir);
if p.join("index.html").exists() {
eprintln!("[WEB] Serving static files from CODEG_STATIC_DIR: {}", p.display());
eprintln!(
"[WEB] Serving static files from CODEG_STATIC_DIR: {}",
p.display()
);
return p;
}
}
@@ -292,12 +303,13 @@ pub(crate) async fn do_start_web_server_with_state(
let host = host.unwrap_or_else(|| "0.0.0.0".to_string());
let token = resolve_web_service_token(&app_state.db.conn, token).await?;
let addr: SocketAddr = format!("{}:{}", host, port)
.parse()
.map_err(|e: std::net::AddrParseError| {
AppCommandError::new(AppErrorCode::InvalidInput, ERR_INVALID_ADDRESS)
.with_detail(e.to_string())
})?;
let addr: SocketAddr =
format!("{}:{}", host, port)
.parse()
.map_err(|e: std::net::AddrParseError| {
AppCommandError::new(AppErrorCode::InvalidInput, ERR_INVALID_ADDRESS)
.with_detail(e.to_string())
})?;
let listener = tokio::net::TcpListener::bind(addr)
.await
@@ -387,12 +399,13 @@ pub async fn start_web_server(
let host_val = host.unwrap_or_else(|| "0.0.0.0".to_string());
let token = resolve_web_service_token(&db.conn, token).await?;
let addr: SocketAddr = format!("{}:{}", host_val, port_val)
.parse()
.map_err(|e: std::net::AddrParseError| {
AppCommandError::new(AppErrorCode::InvalidInput, ERR_INVALID_ADDRESS)
.with_detail(e.to_string())
})?;
let addr: SocketAddr =
format!("{}:{}", host_val, port_val)
.parse()
.map_err(|e: std::net::AddrParseError| {
AppCommandError::new(AppErrorCode::InvalidInput, ERR_INVALID_ADDRESS)
.with_detail(e.to_string())
})?;
let listener = tokio::net::TcpListener::bind(addr)
.await
@@ -410,7 +423,10 @@ pub async fn start_web_server(
},
connection_manager: (*app.state::<crate::acp::manager::ConnectionManager>()).clone_ref(),
terminal_manager: (*app.state::<crate::terminal::manager::TerminalManager>()).clone_ref(),
event_broadcaster: app.state::<Arc<crate::web::event_bridge::WebEventBroadcaster>>().inner().clone(),
event_broadcaster: app
.state::<Arc<crate::web::event_bridge::WebEventBroadcaster>>()
.inner()
.clone(),
emitter: crate::web::event_bridge::EventEmitter::Tauri(app.clone()),
data_dir: app.path().app_data_dir().unwrap_or_default(),
web_server_state: WebServerState::new(), // placeholder; not used by handlers

5
src-tauri/src/web/router.rs
View File

@@ -106,10 +106,7 @@ pub fn build_router(state: Arc<AppState>, token: String, static_dir: std::path::
"/remove_folder_from_workspace",
post(handlers::folders::remove_folder_from_workspace),
)
.route(
"/reorder_folders",
post(handlers::folders::reorder_folders),
)
.route("/reorder_folders", post(handlers::folders::reorder_folders))
.route(
"/add_folder_to_history",
post(handlers::folders::add_folder_to_history),

2
src-tauri/src/web/ws.rs
View File

@@ -1,10 +1,10 @@
use std::sync::Arc;
use axum::extract::ws::{Message, WebSocket};
use axum::{
extract::{Extension, WebSocketUpgrade},
response::IntoResponse,
};
use axum::extract::ws::{Message, WebSocket};
use crate::app_state::AppState;