Remove red color from error messages

1 files changed, 76 insertions, 115 deletions

diff --git a/src/bin/jv.rs b/src/bin/jv.rs
index 51f73dd..1ac440f 100644
--- a/src/bin/jv.rs
+++ b/src/bin/jv.rs
@@ -537,7 +537,7 @@ async fn main() {
     colored::control::set_virtual_terminal(true).unwrap();
 
     let Ok(parser) = JustEnoughVcsWorkspace::try_parse() else {
-        eprintln!("{}", md(t!("jv.fail.parse.parser_failed")).red());
+        eprintln!("{}", md(t!("jv.fail.parse.parser_failed")));
 
         // Tips
         // Guide to create
@@ -677,7 +677,7 @@ async fn main() {
             let user_dir = match UserDirectory::current_doc_dir() {
                 Some(dir) => dir,
                 None => {
-                    eprintln!("{}", t!("jv.fail.account.no_user_dir").red());
+                    eprintln!("{}", t!("jv.fail.account.no_user_dir"));
                     return;
                 }
             };
@@ -856,7 +856,7 @@ async fn main() {
             let user_dir = match UserDirectory::current_doc_dir() {
                 Some(dir) => dir,
                 None => {
-                    eprintln!("{}", t!("jv.fail.account.no_user_dir").red());
+                    eprintln!("{}", t!("jv.fail.account.no_user_dir"));
                     return;
                 }
             };
@@ -873,7 +873,7 @@ async fn main() {
             let user_dir = match UserDirectory::current_doc_dir() {
                 Some(dir) => dir,
                 None => {
-                    eprintln!("{}", t!("jv.fail.account.no_user_dir").red());
+                    eprintln!("{}", t!("jv.fail.account.no_user_dir"));
                     return;
                 }
             };
@@ -903,7 +903,7 @@ async fn main() {
             let user_dir = match UserDirectory::current_doc_dir() {
                 Some(dir) => dir,
                 None => {
-                    eprintln!("{}", t!("jv.fail.account.no_user_dir").red());
+                    eprintln!("{}", t!("jv.fail.account.no_user_dir"));
                     return;
                 }
             };
@@ -942,7 +942,7 @@ async fn jv_create(args: CreateWorkspaceArgs) {
     };
 
     if !args.force && path.exists() && !is_directory_empty(&path).await {
-        eprintln!("{}", t!("jv.fail.init_create_dir_not_empty").trim().red());
+        eprintln!("{}", t!("jv.fail.init_create_dir_not_empty").trim());
         return;
     }
 
@@ -951,7 +951,7 @@ async fn jv_create(args: CreateWorkspaceArgs) {
             println!("{}", t!("jv.success.create"));
         }
         Err(e) => {
-            eprintln!("{}", t!("jv.fail.create", error = e.to_string()).red());
+            eprintln!("{}", t!("jv.fail.create", error = e.to_string()));
         }
     }
 }
@@ -960,16 +960,13 @@ async fn jv_init(args: InitWorkspaceArgs) {
     let path = match current_dir() {
         Ok(path) => path,
         Err(e) => {
-            eprintln!(
-                "{}",
-                t!("jv.fail.get_current_dir", error = e.to_string()).red()
-            );
+            eprintln!("{}", t!("jv.fail.get_current_dir", error = e.to_string()));
             return;
         }
     };
 
     if !args.force && path.exists() && !is_directory_empty(&path).await {
-        eprintln!("{}", t!("jv.fail.init_create_dir_not_empty").trim().red());
+        eprintln!("{}", t!("jv.fail.init_create_dir_not_empty").trim());
         return;
     }
 
@@ -978,7 +975,7 @@ async fn jv_init(args: InitWorkspaceArgs) {
             println!("{}", t!("jv.success.init"));
         }
         Err(e) => {
-            eprintln!("{}", t!("jv.fail.init", error = e.to_string()).red());
+            eprintln!("{}", t!("jv.fail.init", error = e.to_string()));
         }
     }
 }
@@ -992,18 +989,18 @@ async fn is_directory_empty(path: &PathBuf) -> bool {
 
 async fn jv_here(_args: HereArgs) {
     let Some(local_dir) = current_local_path() else {
-        eprintln!("{}", t!("jv.fail.workspace_not_found").trim().red());
+        eprintln!("{}", t!("jv.fail.workspace_not_found").trim());
         return;
     };
 
     let Ok(latest_info) = LatestInfo::read_from(local_dir.join(CLIENT_FILE_LATEST_INFO)).await
     else {
-        eprintln!("{}", md(t!("jv.fail.read_cfg")).red());
+        eprintln!("{}", md(t!("jv.fail.read_cfg")));
         return;
     };
 
     let Ok(local_cfg) = LocalConfig::read_from(local_dir.join(CLIENT_FILE_WORKSPACE)).await else {
-        eprintln!("{}", md(t!("jv.fail.read_cfg")).red());
+        eprintln!("{}", md(t!("jv.fail.read_cfg")));
         return;
     };
 
@@ -1017,7 +1014,7 @@ async fn jv_here(_args: HereArgs) {
     let path = match current_dir() {
         Ok(path) => path,
         Err(_) => {
-            eprintln!("{}", t!("jv.fail.get_current_dir").red());
+            eprintln!("{}", t!("jv.fail.get_current_dir"));
             return;
         }
     };
@@ -1025,7 +1022,7 @@ async fn jv_here(_args: HereArgs) {
     let local_dir = match current_local_path() {
         Some(path) => path,
         None => {
-            eprintln!("{}", t!("jv.fail.workspace_not_found").trim().red());
+            eprintln!("{}", t!("jv.fail.workspace_not_found").trim());
             return;
         }
     };
@@ -1128,49 +1125,49 @@ async fn jv_here(_args: HereArgs) {
 
 async fn jv_status(_args: StatusArgs) {
     let Some(local_dir) = current_local_path() else {
-        eprintln!("{}", md(t!("jv.fail.workspace_not_found")).trim().red());
+        eprintln!("{}", md(t!("jv.fail.workspace_not_found")).trim());
         return;
     };
 
     let Ok(local_cfg) = LocalConfig::read_from(local_dir.join(CLIENT_FILE_WORKSPACE)).await else {
-        eprintln!("{}", md(t!("jv.fail.read_cfg")).red());
+        eprintln!("{}", md(t!("jv.fail.read_cfg")));
         return;
     };
 
     let account = local_cfg.current_account();
 
     let Ok(member_held_path) = MemberHeld::held_file_path(&account) else {
-        eprintln!("{}", md(t!("jv.fail.read_cfg")).red());
+        eprintln!("{}", md(t!("jv.fail.read_cfg")));
         return;
     };
 
     let Ok(member_held) = MemberHeld::read_from(&member_held_path).await else {
-        eprintln!("{}", md(t!("jv.fail.read_cfg")).red());
+        eprintln!("{}", md(t!("jv.fail.read_cfg")));
         return;
     };
 
     let Some(sheet_name) = local_cfg.sheet_in_use().clone() else {
-        eprintln!("{}", md(t!("jv.fail.status.no_sheet_in_use")).trim().red());
+        eprintln!("{}", md(t!("jv.fail.status.no_sheet_in_use")).trim());
         return;
     };
 
     let Some(local_workspace) = LocalWorkspace::init_current_dir(local_cfg) else {
-        eprintln!("{}", md(t!("jv.fail.workspace_not_found")).trim().red());
+        eprintln!("{}", md(t!("jv.fail.workspace_not_found")).trim());
         return;
     };
 
     let Ok(local_sheet) = local_workspace.local_sheet(&account, &sheet_name).await else {
-        eprintln!("{}", md(t!("jv.fail.read_cfg")).red());
+        eprintln!("{}", md(t!("jv.fail.read_cfg")));
         return;
     };
 
     let Ok(cached_sheet) = CachedSheet::cached_sheet_data(&sheet_name).await else {
-        eprintln!("{}", md(t!("jv.fail.read_cfg")).red());
+        eprintln!("{}", md(t!("jv.fail.read_cfg")));
         return;
     };
 
     let Ok(analyzed) = AnalyzeResult::analyze_local_status(&local_workspace).await else {
-        eprintln!("{}", md(t!("jv.fail.status.analyze")).trim().red());
+        eprintln!("{}", md(t!("jv.fail.status.analyze")).trim());
         return;
     };
 
@@ -1204,7 +1201,6 @@ async fn jv_status(_args: StatusArgs) {
                 path = path.display().to_string()
             )
             .trim()
-            .red()
             .to_string()
         })
         .collect();
@@ -1263,7 +1259,6 @@ async fn jv_status(_args: StatusArgs) {
                     reason = t!("jv.success.status.invalid_modified_reasons.not_holder")
                 )
                 .trim()
-                .red()
                 .to_string();
             }
 
@@ -1275,7 +1270,6 @@ async fn jv_status(_args: StatusArgs) {
                     reason = t!("jv.success.status.invalid_modified_reasons.base_version_mismatch")
                 )
                 .trim()
-                .red()
                 .to_string();
             }
 
@@ -1355,21 +1349,21 @@ async fn jv_status(_args: StatusArgs) {
 async fn jv_sheet_list(args: SheetListArgs) {
     let Some(_local_dir) = current_local_path() else {
         if !args.raw {
-            eprintln!("{}", t!("jv.fail.workspace_not_found").trim().red());
+            eprintln!("{}", t!("jv.fail.workspace_not_found").trim());
         }
         return;
     };
 
     let Ok(latest_info) = LatestInfo::read().await else {
         if !args.raw {
-            eprintln!("{}", md(t!("jv.fail.read_cfg")).red());
+            eprintln!("{}", md(t!("jv.fail.read_cfg")));
         }
         return;
     };
 
     let Ok(local_cfg) = LocalConfig::read().await else {
         if !args.raw {
-            eprintln!("{}", md(t!("jv.fail.read_cfg")).red());
+            eprintln!("{}", md(t!("jv.fail.read_cfg")));
         }
         return;
     };
@@ -1465,19 +1459,19 @@ async fn jv_sheet_list(args: SheetListArgs) {
 
 async fn jv_sheet_use(args: SheetUseArgs) {
     let Some(_local_dir) = current_local_path() else {
-        eprintln!("{}", t!("jv.fail.workspace_not_found").trim().red());
+        eprintln!("{}", t!("jv.fail.workspace_not_found").trim());
         return;
     };
 
     let Ok(mut local_cfg) = LocalConfig::read().await else {
-        eprintln!("{}", md(t!("jv.fail.read_cfg")).red());
+        eprintln!("{}", md(t!("jv.fail.read_cfg")));
         return;
     };
 
     match local_cfg.use_sheet(args.sheet_name.clone()).await {
         Ok(_) => {
             let Ok(_) = LocalConfig::write(&local_cfg).await else {
-                eprintln!("{}", t!("jv.fail.write_cfg").trim().red());
+                eprintln!("{}", t!("jv.fail.write_cfg").trim());
                 return;
             };
         }
@@ -1486,7 +1480,7 @@ async fn jv_sheet_use(args: SheetUseArgs) {
             std::io::ErrorKind::NotFound => {
                 eprintln!(
                     "{}",
-                    md(t!("jv.fail.use.sheet_not_exists", name = args.sheet_name)).red()
+                    md(t!("jv.fail.use.sheet_not_exists", name = args.sheet_name))
                 );
                 return;
             }
@@ -1497,7 +1491,6 @@ async fn jv_sheet_use(args: SheetUseArgs) {
                         "jv.fail.use.directory_not_empty",
                         name = args.sheet_name
                     ))
-                    .red()
                 );
                 return;
             }
@@ -1510,19 +1503,19 @@ async fn jv_sheet_use(args: SheetUseArgs) {
 
 async fn jv_sheet_exit(_args: SheetExitArgs) {
     let Some(_local_dir) = current_local_path() else {
-        eprintln!("{}", t!("jv.fail.workspace_not_found").trim().red());
+        eprintln!("{}", t!("jv.fail.workspace_not_found").trim());
         return;
     };
 
     let Ok(mut local_cfg) = LocalConfig::read().await else {
-        eprintln!("{}", md(t!("jv.fail.read_cfg")).red());
+        eprintln!("{}", md(t!("jv.fail.read_cfg")));
         return;
     };
 
     match local_cfg.exit_sheet().await {
         Ok(_) => {
             let Ok(_) = LocalConfig::write(&local_cfg).await else {
-                eprintln!("{}", t!("jv.fail.write_cfg").trim().red());
+                eprintln!("{}", t!("jv.fail.write_cfg").trim());
                 return;
             };
         }
@@ -1556,7 +1549,7 @@ async fn jv_sheet_make(args: SheetMakeArgs) {
     let latest_info = match LatestInfo::read().await {
         Ok(info) => info,
         Err(_) => {
-            eprintln!("{}", t!("jv.fail.read_cfg").red());
+            eprintln!("{}", t!("jv.fail.read_cfg"));
             return;
         }
     };
@@ -1593,10 +1586,7 @@ async fn jv_sheet_make(args: SheetMakeArgs) {
                 )
             }
             MakeSheetActionResult::AuthorizeFailed(e) => {
-                eprintln!(
-                    "{}",
-                    md(t!("jv.result.common.authroize_failed", err = e)).red()
-                )
+                eprintln!("{}", md(t!("jv.result.common.authroize_failed", err = e)))
             }
             MakeSheetActionResult::SheetAlreadyExists => {
                 eprintln!(
@@ -1605,13 +1595,12 @@ async fn jv_sheet_make(args: SheetMakeArgs) {
                         "jv.result.sheet.make.sheet_already_exists",
                         name = sheet_name
                     ))
-                    .red()
                 );
             }
             MakeSheetActionResult::SheetCreationFailed(e) => {
                 eprintln!(
                     "{}",
-                    md(t!("jv.result.sheet.make.sheet_creation_failed", err = e)).red()
+                    md(t!("jv.result.sheet.make.sheet_creation_failed", err = e))
                 )
             }
             MakeSheetActionResult::Unknown => todo!(),
@@ -1654,14 +1643,11 @@ async fn jv_sheet_drop(args: SheetDropArgs) {
             DropSheetActionResult::SheetInUse => {
                 eprintln!(
                     "{}",
-                    md(t!("jv.result.sheet.drop.sheet_in_use", name = sheet_name)).red()
+                    md(t!("jv.result.sheet.drop.sheet_in_use", name = sheet_name))
                 )
             }
             DropSheetActionResult::AuthorizeFailed(e) => {
-                eprintln!(
-                    "{}",
-                    md(t!("jv.result.common.authroize_failed", err = e)).red()
-                )
+                eprintln!("{}", md(t!("jv.result.common.authroize_failed", err = e)))
             }
             DropSheetActionResult::SheetNotExists => {
                 eprintln!(
@@ -1670,25 +1656,24 @@ async fn jv_sheet_drop(args: SheetDropArgs) {
                         "jv.result.sheet.drop.sheet_not_exists",
                         name = sheet_name
                     ))
-                    .red()
                 )
             }
             DropSheetActionResult::SheetDropFailed(e) => {
                 eprintln!(
                     "{}",
-                    md(t!("jv.result.sheet.drop.sheet_drop_failed", err = e)).red()
+                    md(t!("jv.result.sheet.drop.sheet_drop_failed", err = e))
                 )
             }
             DropSheetActionResult::NoHolder => {
                 eprintln!(
                     "{}",
-                    md(t!("jv.result.sheet.drop.no_holder", name = sheet_name)).red()
+                    md(t!("jv.result.sheet.drop.no_holder", name = sheet_name))
                 )
             }
             DropSheetActionResult::NotOwner => {
                 eprintln!(
                     "{}",
-                    md(t!("jv.result.sheet.drop.not_owner", name = sheet_name)).red()
+                    md(t!("jv.result.sheet.drop.not_owner", name = sheet_name))
                 )
             }
             _ => {}
@@ -1711,20 +1696,20 @@ async fn jv_track(args: TrackFileArgs) {
     };
 
     let Some(local_dir) = current_local_path() else {
-        eprintln!("{}", t!("jv.fail.workspace_not_found").trim().red());
+        eprintln!("{}", t!("jv.fail.workspace_not_found").trim());
         return;
     };
 
     let Some(files) = get_relative_paths(local_dir, track_files).await else {
         eprintln!(
             "{}",
-            md(t!("jv.fail.track.parse_fail", param = "track_files")).red()
+            md(t!("jv.fail.track.parse_fail", param = "track_files"))
         );
         return;
     };
 
     if files.iter().len() < 1 {
-        eprintln!("{}", md(t!("jv.fail.track.no_selection")).red());
+        eprintln!("{}", md(t!("jv.fail.track.no_selection")));
         return;
     };
 
@@ -1761,16 +1746,10 @@ async fn jv_track(args: TrackFileArgs) {
                 );
             }
             TrackFileActionResult::AuthorizeFailed(e) => {
-                eprintln!(
-                    "{}",
-                    md(t!("jv.result.common.authroize_failed", err = e)).red()
-                )
+                eprintln!("{}", md(t!("jv.result.common.authroize_failed", err = e)))
             }
             TrackFileActionResult::StructureChangesNotSolved => {
-                eprintln!(
-                    "{}",
-                    md(t!("jv.result.track.structure_changes_not_solved")).red()
-                )
+                eprintln!("{}", md(t!("jv.result.track.structure_changes_not_solved")))
             }
             TrackFileActionResult::CreateTaskFailed(create_task_result) => match create_task_result
             {
@@ -1782,7 +1761,6 @@ async fn jv_track(args: TrackFileArgs) {
                             "jv.result.track.create_failed.create_file_on_exist_path",
                             path = path.display()
                         ))
-                        .red()
                     )
                 }
                 CreateTaskResult::SheetNotFound(sheet) => {
@@ -1792,7 +1770,6 @@ async fn jv_track(args: TrackFileArgs) {
                             "jv.result.track.create_failed.sheet_not_found",
                             name = sheet
                         ))
-                        .red()
                     )
                 }
             },
@@ -1834,10 +1811,7 @@ async fn jv_account_add(user_dir: UserDirectory, args: AccountAddArgs) {
             );
         }
         Err(_) => {
-            eprintln!(
-                "{}",
-                t!("jv.fail.account.add", account = args.account_name).red()
-            );
+            eprintln!("{}", t!("jv.fail.account.add", account = args.account_name));
         }
     }
 }
@@ -1853,7 +1827,7 @@ async fn jv_account_remove(user_dir: UserDirectory, args: AccountRemoveArgs) {
         Err(_) => {
             eprintln!(
                 "{}",
-                t!("jv.fail.account.remove", account = args.account_name).red()
+                t!("jv.fail.account.remove", account = args.account_name)
             );
         }
     }
@@ -1891,7 +1865,7 @@ async fn jv_account_list(user_dir: UserDirectory, args: AccountListArgs) {
             }
         }
         Err(_) => {
-            eprintln!("{}", t!("jv.fail.account.list").red());
+            eprintln!("{}", t!("jv.fail.account.list"));
         }
     }
 }
@@ -1901,28 +1875,28 @@ async fn jv_account_as(user_dir: UserDirectory, args: SetLocalWorkspaceAccountAr
     let Ok(member) = user_dir.account(&args.account_name).await else {
         eprintln!(
             "{}",
-            t!("jv.fail.account.not_found", account = args.account_name).red()
+            t!("jv.fail.account.not_found", account = args.account_name)
         );
         return;
     };
 
     let Some(_local_dir) = current_local_path() else {
-        eprintln!("{}", t!("jv.fail.workspace_not_found").trim().red());
+        eprintln!("{}", t!("jv.fail.workspace_not_found").trim());
         return;
     };
 
     let Ok(mut local_cfg) = LocalConfig::read().await else {
-        eprintln!("{}", md(t!("jv.fail.read_cfg")).red());
+        eprintln!("{}", md(t!("jv.fail.read_cfg")));
         return;
     };
 
     if let Err(_) = local_cfg.set_current_account(member.id()) {
-        eprintln!("{}", md(t!("jv.fail.account.as")).red());
+        eprintln!("{}", md(t!("jv.fail.account.as")));
         return;
     };
 
     let Ok(_) = LocalConfig::write(&local_cfg).await else {
-        eprintln!("{}", t!("jv.fail.write_cfg").trim().red());
+        eprintln!("{}", t!("jv.fail.write_cfg").trim());
         return;
     };
 
@@ -1937,7 +1911,7 @@ async fn jv_account_move_key(user_dir: UserDirectory, args: MoveKeyToAccountArgs
     if !args.key_path.exists() {
         eprintln!(
             "{}",
-            t!("jv.fail.path_not_found", path = args.key_path.display()).red()
+            t!("jv.fail.path_not_found", path = args.key_path.display())
         );
         return;
     }
@@ -1946,7 +1920,7 @@ async fn jv_account_move_key(user_dir: UserDirectory, args: MoveKeyToAccountArgs
     let Ok(_member) = user_dir.account(&args.account_name).await else {
         eprintln!(
             "{}",
-            t!("jv.fail.account.not_found", account = args.account_name).red()
+            t!("jv.fail.account.not_found", account = args.account_name)
         );
         return;
     };
@@ -1959,7 +1933,7 @@ async fn jv_account_move_key(user_dir: UserDirectory, args: MoveKeyToAccountArgs
     .await
     {
         Ok(_) => println!("{}", t!("jv.success.account.move_key")),
-        Err(_) => eprintln!("{}", t!("jv.fail.account.move_key").red()),
+        Err(_) => eprintln!("{}", t!("jv.fail.account.move_key")),
     }
 }
 
@@ -1981,10 +1955,7 @@ async fn jv_update(_update_file_args: UpdateArgs) {
                 println!("{}", md(t!("jv.result.update.success")));
             }
             UpdateToLatestInfoResult::AuthorizeFailed(e) => {
-                eprintln!(
-                    "{}",
-                    md(t!("jv.result.common.authroize_failed", err = e)).red()
-                )
+                eprintln!("{}", md(t!("jv.result.common.authroize_failed", err = e)))
             }
             UpdateToLatestInfoResult::SyncCachedSheetFail(sync_cached_sheet_fail_reason) => {
                 match sync_cached_sheet_fail_reason {
@@ -1995,7 +1966,6 @@ async fn jv_update(_update_file_args: UpdateArgs) {
                                 "jv.result.update.fail.sync_cached_sheet_fail.path_already_exist",
                                 path = path_buf.display()
                             ))
-                            .red()
                         );
                     }
                 }
@@ -2029,7 +1999,6 @@ async fn jv_direct(args: DirectArgs) {
                     str = &upstream.trim(),
                     err = e
                 ))
-                .red()
             );
             return;
         }
@@ -2063,22 +2032,16 @@ async fn jv_direct(args: DirectArgs) {
                 insert_recent_ip_address(upstream.to_string().trim()).await;
             }
             SetUpstreamVaultActionResult::AlreadyStained => {
-                eprintln!("{}", md(t!("jv.result.direct.already_stained")).red())
+                eprintln!("{}", md(t!("jv.result.direct.already_stained")))
             }
             SetUpstreamVaultActionResult::AuthorizeFailed(e) => {
-                eprintln!(
-                    "{}",
-                    md(t!("jv.result.common.authroize_failed", err = e)).red()
-                )
+                eprintln!("{}", md(t!("jv.result.common.authroize_failed", err = e)))
             }
             SetUpstreamVaultActionResult::RedirectFailed(e) => {
-                eprintln!(
-                    "{}",
-                    md(t!("jv.result.direct.redirect_failed", err = e)).red()
-                )
+                eprintln!("{}", md(t!("jv.result.direct.redirect_failed", err = e)))
             }
             SetUpstreamVaultActionResult::SameUpstream => {
-                eprintln!("{}", md(t!("jv.result.direct.same_upstream")).red())
+                eprintln!("{}", md(t!("jv.result.direct.same_upstream")))
             }
             _ => {}
         },
@@ -2087,17 +2050,17 @@ async fn jv_direct(args: DirectArgs) {
 
 async fn jv_unstain(args: UnstainArgs) {
     let Some(_local_dir) = current_local_path() else {
-        eprintln!("{}", t!("jv.fail.workspace_not_found").trim().red());
+        eprintln!("{}", t!("jv.fail.workspace_not_found").trim());
         return;
     };
 
     let Ok(mut local_cfg) = LocalConfig::read().await else {
-        eprintln!("{}", md(t!("jv.fail.read_cfg")).red());
+        eprintln!("{}", md(t!("jv.fail.read_cfg")));
         return;
     };
 
     if !local_cfg.stained() {
-        eprintln!("{}", md(t!("jv.fail.unstain")).red());
+        eprintln!("{}", md(t!("jv.fail.unstain")));
         return;
     }
 
@@ -2112,7 +2075,7 @@ async fn jv_unstain(args: UnstainArgs) {
     local_cfg.unstain();
 
     let Ok(_) = LocalConfig::write(&local_cfg).await else {
-        eprintln!("{}", t!("jv.fail.write_cfg").trim().red());
+        eprintln!("{}", t!("jv.fail.write_cfg").trim());
         return;
     };
 
@@ -2163,7 +2126,7 @@ async fn jv_docs(args: DocsArgs) {
     let Some(document) = document(name) else {
         eprintln!(
             "{}",
-            md(t!("jv.fail.docs.not_found", docs_name = docs_name)).red()
+            md(t!("jv.fail.docs.not_found", docs_name = docs_name))
         );
         return;
     };
@@ -2174,7 +2137,7 @@ async fn jv_docs(args: DocsArgs) {
         let Some(doc_dir) = current_doc_dir() else {
             eprintln!(
                 "{}",
-                md(t!("jv.fail.docs.no_doc_dir", docs_name = docs_name)).red()
+                md(t!("jv.fail.docs.no_doc_dir", docs_name = docs_name))
             );
             return;
         };
@@ -2187,14 +2150,13 @@ async fn jv_docs(args: DocsArgs) {
                     err = e,
                     docs_name = docs_name
                 ))
-                .red()
             );
         }
     }
 }
 
 pub fn handle_err(err: TcpTargetError) {
-    eprintln!("{}", md(t!("jv.fail.from_core", err = err)).red())
+    eprintln!("{}", md(t!("jv.fail.from_core", err = err)))
 }
 
 async fn connect(upstream: SocketAddr) -> Option<ConnectionInstance> {
@@ -2203,7 +2165,7 @@ async fn connect(upstream: SocketAddr) -> Option<ConnectionInstance> {
         match TcpSocket::new_v4() {
             Ok(socket) => socket,
             Err(_) => {
-                eprintln!("{}", t!("jv.fail.create_socket").trim().red());
+                eprintln!("{}", t!("jv.fail.create_socket").trim());
                 return None;
             }
         }
@@ -2211,7 +2173,7 @@ async fn connect(upstream: SocketAddr) -> Option<ConnectionInstance> {
         match TcpSocket::new_v6() {
             Ok(socket) => socket,
             Err(_) => {
-                eprintln!("{}", t!("jv.fail.create_socket").trim().red());
+                eprintln!("{}", t!("jv.fail.create_socket").trim());
                 return None;
             }
         }
@@ -2219,7 +2181,7 @@ async fn connect(upstream: SocketAddr) -> Option<ConnectionInstance> {
 
     // Connect
     let Ok(stream) = socket.connect(upstream).await else {
-        eprintln!("{}", t!("jv.fail.connection_failed").trim().red());
+        eprintln!("{}", t!("jv.fail.connection_failed").trim());
         return None;
     };
 
@@ -2230,7 +2192,7 @@ async fn connect(upstream: SocketAddr) -> Option<ConnectionInstance> {
 // Returns LocalConfig if valid, None otherwise
 async fn precheck() -> Option<LocalConfig> {
     let Some(local_dir) = current_local_path() else {
-        eprintln!("{}", t!("jv.fail.workspace_not_found").trim().red());
+        eprintln!("{}", t!("jv.fail.workspace_not_found").trim());
         return None;
     };
 
@@ -2242,18 +2204,17 @@ async fn precheck() -> Option<LocalConfig> {
                 dir = local_dir.display(),
                 error = e
             )
-            .red()
         );
         return None;
     }
 
     let Ok(local_config) = LocalConfig::read().await else {
-        eprintln!("{}", md(t!("jv.fail.read_cfg")).red());
+        eprintln!("{}", md(t!("jv.fail.read_cfg")));
         return None;
     };
 
     if !local_config.stained() {
-        eprintln!("{}", md(t!("jv.fail.not_stained")).red());
+        eprintln!("{}", md(t!("jv.fail.not_stained")));
         return None;
     }