>(path: P, con: &str) -> Result<()> {
32 | #[cfg(any(target_os = "linux", target_os = "android"))]
33 | {
34 | log::debug!("file: {},con: {}", path.as_ref().display(), con);
35 | xattr_set(&path, SELINUX_XATTR, con.as_bytes()).with_context(|| {
36 | format!(
37 | "Failed to change SELinux context for {}",
38 | path.as_ref().display()
39 | )
40 | })?;
41 | }
42 | Ok(())
43 | }
44 |
45 | #[cfg(any(target_os = "linux", target_os = "android"))]
46 | pub fn lgetfilecon(path: P) -> Result
47 | where
48 | P: AsRef,
49 | {
50 | let con = xattr_get(&path, SELINUX_XATTR)
51 | .with_context(|| {
52 | format!(
53 | "Failed to get SELinux context for {}",
54 | path.as_ref().display()
55 | )
56 | })?
57 | .with_context(|| {
58 | format!(
59 | "Failed to get SELinux context for {}",
60 | path.as_ref().display()
61 | )
62 | })?;
63 | let con = String::from_utf8_lossy(&con);
64 | Ok(con.to_string())
65 | }
66 |
67 | #[cfg(not(any(target_os = "linux", target_os = "android")))]
68 | pub fn lgetfilecon(path: P) -> Result
69 | where
70 | P: AsRef,
71 | {
72 | unimplemented!()
73 | }
74 |
75 | pub fn ensure_dir_exists(dir: P) -> Result<()>
76 | where
77 | P: AsRef,
78 | {
79 | let result = create_dir_all(&dir);
80 | if dir.as_ref().is_dir() && result.is_ok() {
81 | Ok(())
82 | } else {
83 | bail!("{} is not a regular directory", dir.as_ref().display())
84 | }
85 | }
86 |
87 | fn is_ok_empty(dir: P) -> bool
88 | where
89 | P: AsRef,
90 | {
91 | dir.as_ref()
92 | .read_dir()
93 | .is_ok_and(|mut entries| entries.next().is_none())
94 | }
95 |
96 | pub fn select_temp_dir() -> Result {
97 | for candidate in TMPFS_CANDIDATES {
98 | let path = Path::new(candidate);
99 |
100 | if !path.exists() {
101 | continue;
102 | }
103 |
104 | if is_ok_empty(path) {
105 | log::info!("selected tmpfs: {}", path.display(),);
106 | return Ok(path.to_path_buf());
107 | }
108 | }
109 |
110 | bail!(
111 | "no tmpfs found in candidates: {}",
112 | TMPFS_CANDIDATES.join(", ")
113 | )
114 | }
115 |
--------------------------------------------------------------------------------
/webui/src/components/MagicLogo.svelte:
--------------------------------------------------------------------------------
1 |
3 |
4 |
5 |
39 |
81 | {#if !isReady}
82 |
83 |
84 |
Loading...
85 |
86 | {:else}
87 |
88 |
94 |
97 |
98 |
99 |
100 |
101 |
102 |
104 |
105 | {/if}
106 |
107 |
(&mut self, module_dir: P) -> Result
70 | where
71 | P: AsRef,
72 | {
73 | let dir = module_dir.as_ref();
74 | let mut has_file = false;
75 | for entry in dir.read_dir()?.flatten() {
76 | let name = entry.file_name().to_string_lossy().to_string();
77 |
78 | let node = match self.children.entry(name.clone()) {
79 | Entry::Occupied(o) => Some(o.into_mut()),
80 | Entry::Vacant(v) => Self::new_module(&name, &entry).map(|it| v.insert(it)),
81 | };
82 |
83 | if let Some(node) = node {
84 | has_file |= if node.file_type == NodeFileType::Directory {
85 | node.collect_module_files(dir.join(&node.name))? || node.replace
86 | } else {
87 | true
88 | }
89 | }
90 | }
91 |
92 | Ok(has_file)
93 | }
94 |
95 | pub fn new_root(name: S) -> Self
96 | where
97 | S: AsRef + Into,
98 | {
99 | Self {
100 | name: name.into(),
101 | file_type: NodeFileType::Directory,
102 | children: HashMap::default(),
103 | module_path: None,
104 | replace: false,
105 | skip: false,
106 | }
107 | }
108 |
109 | pub fn new_module(name: &S, entry: &DirEntry) -> Option
110 | where
111 | S: AsRef + Into,
112 | std::string::String: for<'a> From<&'a S>,
113 | {
114 | if let Ok(metadata) = entry.metadata() {
115 | let path = entry.path();
116 | let file_type = if metadata.file_type().is_char_device() && metadata.rdev() == 0 {
117 | Some(NodeFileType::Whiteout)
118 | } else {
119 | Some(NodeFileType::from(metadata.file_type()))
120 | };
121 | if let Some(file_type) = file_type {
122 | let replace = if file_type == NodeFileType::Directory
123 | && let Ok(v) = xattr_get(&path, REPLACE_DIR_XATTR).with_context(|| {
124 | format!("Failed to get SELinux context for {}", path.display())
125 | })
126 | && let Some(s) = v
127 | && String::from_utf8_lossy(&s) == "y"
128 | {
129 | true
130 | } else {
131 | false
132 | };
133 | return Some(Self {
134 | name: name.into(),
135 | file_type,
136 | children: HashMap::default(),
137 | module_path: Some(path),
138 | replace,
139 | skip: false,
140 | });
141 | }
142 | }
143 |
144 | None
145 | }
146 | }
147 |
--------------------------------------------------------------------------------
/webui/src/app.css:
--------------------------------------------------------------------------------
1 | :root {
2 | --md-sys-shape-corner-medium: 12px;
3 | --md-sys-shape-corner-large: 16px;
4 | --md-sys-shape-corner-full: 9999px;
5 | --md-sys-color-shadow: #000000;
6 | --md-sys-elevation-1: 0 1px 2px 0 rgba(0,0,0,0.3), 0 1px 3px 1px rgba(0,0,0,0.15);
7 | --md-sys-elevation-2: 0 1px 2px 0 rgba(0,0,0,0.3), 0 2px 6px 2px rgba(0,0,0,0.15);
8 | --md-sys-elevation-3: 0 4px 8px 3px rgba(0,0,0,0.15), 0 1px 3px 0 rgba(0,0,0,0.3);
9 | --font-common: system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
10 | --md-ref-typeface-plain: var(--font-stack, var(--font-common));
11 | --md-ref-typeface-mono: 'JetBrains Mono', 'Fira Code', monospace;
12 | }
13 | * {
14 | box-sizing: border-box;
15 | -webkit-tap-highlight-color: transparent;
16 | }
17 | html, body, #app {
18 | height: 100%;
19 | width: 100%;
20 | margin: 0;
21 | padding: 0;
22 | overflow: hidden;
23 | background-color: var(--md-sys-color-background);
24 | color: var(--md-sys-color-on-background);
25 | font-family: var(--md-ref-typeface-plain);
26 | font-size: 16px;
27 | line-height: 1.5;
28 | -webkit-font-smoothing: antialiased;
29 | -moz-osx-font-smoothing: grayscale;
30 | }
31 | input, select, textarea, button {
32 | font-family: inherit;
33 | }
34 | button {
35 | border: none;
36 | cursor: pointer;
37 | transition: all 0.2s cubic-bezier(0.4, 0, 0.2, 1);
38 | flex-shrink: 0;
39 | white-space: nowrap;
40 | }
41 | button:active {
42 | transform: scale(0.96);
43 | }
44 | .btn-filled {
45 | height: 44px;
46 | min-width: 90px;
47 | padding: 0 20px;
48 | border-radius: 12px;
49 | background-color: var(--md-sys-color-primary);
50 | color: var(--md-sys-color-on-primary);
51 | font-weight: 600;
52 | font-size: 14px;
53 | display: inline-flex;
54 | align-items: center;
55 | justify-content: center;
56 | gap: 8px;
57 | box-shadow: none;
58 | }
59 | .btn-filled:disabled {
60 | background-color: var(--md-sys-color-on-surface);
61 | opacity: 0.12;
62 | color: var(--md-sys-color-surface);
63 | cursor: not-allowed;
64 | box-shadow: none;
65 | }
66 | .btn-tonal {
67 | height: 44px;
68 | min-width: 90px;
69 | padding: 0 20px;
70 | border-radius: 12px;
71 | background-color: var(--md-sys-color-secondary-container);
72 | color: var(--md-sys-color-on-secondary-container);
73 | font-weight: 600;
74 | font-size: 14px;
75 | display: inline-flex;
76 | align-items: center;
77 | justify-content: center;
78 | gap: 8px;
79 | }
80 | .btn-icon {
81 | width: 40px;
82 | height: 40px;
83 | border-radius: 50%;
84 | background: transparent;
85 | color: var(--md-sys-color-on-surface-variant);
86 | display: flex;
87 | align-items: center;
88 | justify-content: center;
89 | }
90 | .btn-icon:hover {
91 | background-color: rgba(128,128,128, 0.1);
92 | }
93 | .md3-card {
94 | background-color: var(--md-sys-color-surface-container);
95 | border: 1px solid var(--md-sys-color-outline-variant);
96 | border-radius: var(--md-sys-shape-corner-large);
97 | padding: 20px;
98 | display: flex;
99 | flex-direction: column;
100 | gap: 16px;
101 | margin-bottom: 16px;
102 | box-shadow: none;
103 | }
104 | .text-field {
105 | position: relative;
106 | }
107 | .text-field input, .text-field select {
108 | width: 100%;
109 | height: 56px;
110 | background: var(--md-sys-color-surface-container-highest);
111 | border: 1px solid var(--md-sys-color-outline);
112 | border-bottom: 1px solid var(--md-sys-color-outline);
113 | border-radius: 4px 4px 0 0;
114 | padding: 0 16px;
115 | color: var(--md-sys-color-on-surface);
116 | font-size: 16px;
117 | outline: none;
118 | transition: all 0.2s;
119 | appearance: none;
120 | }
121 | .text-field input:focus, .text-field select:focus {
122 | border-bottom: 2px solid var(--md-sys-color-primary);
123 | border-color: var(--md-sys-color-primary);
124 | background: var(--md-sys-color-surface-container-highest);
125 | padding-left: 16px;
126 | padding-right: 16px;
127 | }
128 | .text-field label {
129 | position: absolute;
130 | top: 8px;
131 | left: 12px;
132 | background-color: transparent;
133 | padding: 0 4px;
134 | font-size: 12px;
135 | color: var(--md-sys-color-on-surface-variant);
136 | z-index: 1;
137 | pointer-events: none;
138 | }
139 | .text-field input:focus ~ label,
140 | .text-field select:focus ~ label {
141 | color: var(--md-sys-color-primary);
142 | }
143 | .bottom-actions {
144 | position: absolute;
145 | bottom: 0;
146 | left: 0;
147 | right: 0;
148 | padding: 16px 24px calc(16px + env(safe-area-inset-bottom)) 24px;
149 | background: linear-gradient(to top, var(--md-sys-color-surface) 85%, transparent);
150 | display: flex;
151 | justify-content: flex-end;
152 | align-items: center;
153 | gap: 12px;
154 | z-index: 50;
155 | pointer-events: none;
156 | }
157 | .bottom-actions button {
158 | pointer-events: auto;
159 | }
160 | code, pre {
161 | font-family: var(--md-ref-typeface-mono);
162 | }
--------------------------------------------------------------------------------
/webui/src/routes/ModulesTab.css:
--------------------------------------------------------------------------------
1 | .modules-container {
2 | display: flex;
3 | flex-direction: column;
4 | gap: 16px;
5 | padding: 16px;
6 | padding-bottom: 80px;
7 | }
8 |
9 | /* Description Card */
10 | .desc-card {
11 | background-color: var(--md-sys-color-secondary-container);
12 | color: var(--md-sys-color-on-secondary-container);
13 | border-radius: 16px;
14 | padding: 16px;
15 | display: flex;
16 | align-items: center;
17 | gap: 16px;
18 | }
19 |
20 | .desc-icon {
21 | display: flex;
22 | align-items: center;
23 | justify-content: center;
24 | }
25 |
26 | .desc-text {
27 | font-size: 14px;
28 | line-height: 1.4;
29 | margin: 0;
30 | }
31 |
32 | /* Search Section */
33 | .search-section {
34 | display: flex;
35 | flex-direction: column;
36 | }
37 |
38 | .search-field {
39 | width: 100%;
40 | /* Match the 16px border-radius of module-card and desc-card */
41 | --md-outlined-text-field-container-shape: 16px;
42 | }
43 |
44 | /* Empty State */
45 | .empty-state {
46 | display: flex;
47 | flex-direction: column;
48 | align-items: center;
49 | justify-content: center;
50 | padding: 48px 0;
51 | gap: 16px;
52 | color: var(--md-sys-color-on-surface-variant);
53 | }
54 |
55 | .empty-icon {
56 | width: 64px;
57 | height: 64px;
58 | border-radius: 50%;
59 | background-color: var(--md-sys-color-surface-container-high);
60 | display: flex;
61 | align-items: center;
62 | justify-content: center;
63 | }
64 |
65 | .empty-icon md-icon {
66 | font-size: 32px;
67 | width: 32px;
68 | height: 32px;
69 | }
70 |
71 | /* Modules List */
72 | .modules-list {
73 | display: flex;
74 | flex-direction: column;
75 | gap: 12px;
76 | }
77 |
78 | .module-card {
79 | background-color: var(--md-sys-color-surface-container);
80 | border-radius: 16px;
81 | overflow: hidden;
82 | transition: background-color 0.2s;
83 | border: 1px solid transparent;
84 | }
85 |
86 | .module-card.expanded {
87 | background-color: var(--md-sys-color-surface-container-high);
88 | border-color: var(--md-sys-color-outline-variant);
89 | }
90 |
91 | .module-card.unmounted {
92 | opacity: 0.8;
93 | }
94 |
95 | .card-main {
96 | position: relative;
97 | padding: 16px;
98 | display: flex;
99 | justify-content: space-between;
100 | align-items: center;
101 | cursor: pointer;
102 | }
103 |
104 | .module-info {
105 | display: flex;
106 | flex-direction: column;
107 | gap: 4px;
108 | }
109 |
110 | .module-name {
111 | font-size: 16px;
112 | font-weight: 500;
113 | color: var(--md-sys-color-on-surface);
114 | }
115 |
116 | .module-meta-row {
117 | display: flex;
118 | align-items: center;
119 | gap: 8px;
120 | }
121 |
122 | .module-id {
123 | font-size: 12px;
124 | font-family: monospace;
125 | color: var(--md-sys-color-on-surface-variant);
126 | }
127 |
128 | .version-tag {
129 | font-size: 10px;
130 | background-color: var(--md-sys-color-surface-variant);
131 | color: var(--md-sys-color-on-surface-variant);
132 | padding: 2px 6px;
133 | border-radius: 4px;
134 | font-family: monospace;
135 | }
136 |
137 | /* Status Badge */
138 | .status-badge {
139 | font-size: 12px;
140 | font-weight: 500;
141 | padding: 6px 12px;
142 | border-radius: 20px;
143 | text-transform: uppercase;
144 | letter-spacing: 0.5px;
145 | }
146 |
147 | .status-badge.magic {
148 | background-color: var(--md-sys-color-primary-container);
149 | color: var(--md-sys-color-on-primary-container);
150 | }
151 |
152 | .status-badge.skipped {
153 | background-color: var(--md-sys-color-surface-variant);
154 | color: var(--md-sys-color-on-surface-variant);
155 | }
156 |
157 | /* Details Section */
158 | .card-details {
159 | padding: 0 16px 16px;
160 | border-top: 1px solid var(--md-sys-color-outline-variant);
161 | margin-top: 0;
162 | padding-top: 16px;
163 | display: flex;
164 | flex-direction: column;
165 | gap: 12px;
166 | }
167 |
168 | .detail-row {
169 | display: flex;
170 | flex-direction: column;
171 | gap: 2px;
172 | }
173 |
174 | .detail-row.description {
175 | margin-top: 4px;
176 | }
177 |
178 | .detail-label {
179 | font-size: 11px;
180 | text-transform: uppercase;
181 | color: var(--md-sys-color-primary);
182 | font-weight: 500;
183 | }
184 |
185 | .detail-value {
186 | font-size: 14px;
187 | color: var(--md-sys-color-on-surface);
188 | margin: 0;
189 | line-height: 1.5;
190 | }
191 |
192 | /* Alert Box */
193 | .status-alert {
194 | display: flex;
195 | align-items: center;
196 | gap: 12px;
197 | background-color: var(--md-sys-color-error-container);
198 | color: var(--md-sys-color-on-error-container);
199 | padding: 12px;
200 | border-radius: 12px;
201 | font-size: 13px;
202 | margin-top: 8px;
203 | }
204 |
205 | .alert-icon {
206 | color: inherit;
207 | }
208 |
209 | /* Skeleton */
210 | .skeleton-card {
211 | padding: 16px;
212 | min-height: 72px;
213 | }
--------------------------------------------------------------------------------
/cliff.toml:
--------------------------------------------------------------------------------
1 | # git-cliff ~ configuration file
2 | # https://git-cliff.org/docs/configuration
3 |
4 | [changelog]
5 | # A Tera template to be rendered for each release in the changelog.
6 | # See https://keats.github.io/tera/docs/#introduction
7 | body = """
8 | {% if version %}\
9 | ## {{ version | trim_start_matches(pat="v") }} - {{ timestamp | date(format="%Y-%m-%d") }}
10 | {% else %}\
11 | ## Unreleased
12 | {% endif %}\
13 | {% if previous %}\
14 | {% if previous.commit_id and commit_id %}
15 | **[View changes](https://github.com/{{ remote.github.owner }}/{{ remote.github.repo }}/compare/{{ previous.commit_id }}...{{ commit_id }})**\
16 | ({{ previous.commit_id | truncate(length=7, end="") }}...{{ commit_id | truncate(length=7, end="") }})
17 | {% endif %}\
18 | {% endif %}\
19 | {% for group, commits in commits | group_by(attribute="group") %}
20 | ### {{ group | upper_first }}
21 | {% for commit in commits %}
22 | - {{ commit.message | split(pat="\n") | first | upper_first | trim }}\
23 | ([{{ commit.id | truncate(length=7, end="") }}](https://github.com/{{ remote.github.owner }}/{{ remote.github.repo }}/commit/{{ commit.id }}))\
24 | {% endfor %}
25 | {% endfor %}\n
26 | """
27 |
28 | # Remove leading and trailing whitespaces from the changelog's body.
29 | trim = true
30 | # Render body even when there are no releases to process.
31 | render_always = true
32 |
33 | # An array of regex based postprocessors to modify the changelog.
34 | postprocessors = [
35 | # Replace the placeholder with a URL.
36 | #{ pattern = '', replace = "https://github.com/orhun/git-cliff" },
37 | ]
38 |
39 | # Footer template
40 | footer = """
41 | {% if previous %}\
42 | **Full Changelog**: [{{ previous.version }}...{{ version }}]({{ remote.github }}/compare/{{ previous.version }}...{{ version }})\
43 | {% endif %}
44 | """
45 |
46 | # Remote repository configuration
47 | [remote.github]
48 | owner = "Tools-cx-app"
49 | repo = "meta-magic_mount"
50 |
51 | [git]
52 | # Parse commits according to the conventional commits specification.
53 | # See https://www.conventionalcommits.org
54 | conventional_commits = true
55 | # Exclude commits that do not match the conventional commits specification.
56 | filter_unconventional = true
57 | # Require all commits to be conventional.
58 | # Takes precedence over filter_unconventional.
59 | require_conventional = false
60 | # Split commits on newlines, treating each line as an individual commit.
61 | split_commits = false
62 |
63 | # An array of regex based parsers to modify commit messages prior to further processing.
64 | commit_preprocessors = [
65 | # Replace issue numbers with link templates to be updated in `changelog.postprocessors`.
66 | #{ pattern = '\((\w+\s)?#([0-9]+)\)', replace = "([#${2}](/issues/${2}))"},
67 | # Check spelling of the commit message using https://github.com/crate-ci/typos.
68 | # If the spelling is incorrect, it will be fixed automatically.
69 | #{ pattern = '.*', replace_command = 'typos --write-changes -' },
70 | ]
71 |
72 | # Prevent commits that are breaking from being excluded by commit parsers.
73 | protect_breaking_commits = false
74 |
75 | # An array of regex based parsers for extracting data from the commit message.
76 | # Assigns commits to groups.
77 | # Optionally sets the commit's scope and can decide to exclude commits from further processing.
78 | commit_parsers = [
79 | { message = "^feat", group = " Features" },
80 | { message = "^fix", group = " Bug Fixes" },
81 | { message = "^doc", group = " Documentation" },
82 | { message = "^perf", group = " Performance" },
83 | { message = "^refactor", group = " Refactor" },
84 | { message = "^style", group = " Styling" },
85 | { message = "^opt", group = " Optimization"},
86 | { message = "^test", group = " Testing" },
87 | { message = "^chore\\(release\\): prepare for", skip = true },
88 | { message = "^chore\\(deps.*\\)", skip = true },
89 | { message = "^chore\\(pr\\)", skip = true },
90 | { message = "^chore\\(pull\\)", skip = true },
91 | { message = "^chore|^ci", group = " Miscellaneous Tasks" },
92 | { body = ".*security", group = " Security" },
93 | { message = "^revert", group = " Revert" },
94 | { message = ".*", group = " Other" },
95 | ]
96 |
97 | # Exclude commits that are not matched by any commit parser.
98 | filter_commits = false
99 | # An array of link parsers for extracting external references, and turning them into URLs, using regex.
100 | link_parsers = []
101 | # Include only the tags that belong to the current branch.
102 | use_branch_tags = false
103 | # Order releases topologically instead of chronologically.
104 | topo_order = false
105 | # Order releases topologically instead of chronologically.
106 | topo_order_commits = true
107 | # Order of commits in each group/release within the changelog.
108 | # Allowed values: newest, oldest
109 | sort_commits = "oldest"
110 | # Process submodules commits
111 | recurse_submodules = false
112 |
--------------------------------------------------------------------------------
/xtask/src/main.rs:
--------------------------------------------------------------------------------
1 | mod zip_ext;
2 |
3 | use std::{
4 | fs,
5 | path::{Path, PathBuf},
6 | process::Command,
7 | };
8 |
9 | use anyhow::Result;
10 | use fs_extra::{dir, file};
11 | use serde::{Deserialize, Serialize};
12 | use zip::{CompressionMethod, write::FileOptions};
13 |
14 | use crate::zip_ext::zip_create_from_directory_with_options;
15 |
16 | #[derive(Deserialize)]
17 | struct Package {
18 | pub version: String,
19 | }
20 |
21 | #[derive(Deserialize)]
22 | struct CargoConfig {
23 | pub package: Package,
24 | }
25 |
26 | #[derive(Serialize)]
27 | struct UpdateJson {
28 | version: String,
29 | #[serde(rename = "versionCode")]
30 | versioncode: usize,
31 | #[serde(rename = "zipUrl")]
32 | zipurl: String,
33 | changelog: String,
34 | }
35 |
36 | fn main() -> Result<()> {
37 | let args: Vec<_> = std::env::args().collect();
38 |
39 | if args.len() == 1 {
40 | return Ok(());
41 | }
42 |
43 | match args[1].as_str() {
44 | "build" | "b" => build()?,
45 | "update" | "u" => update()?,
46 | _ => {}
47 | }
48 |
49 | Ok(())
50 | }
51 |
52 | fn cal_version_code(version: &str) -> Result {
53 | let manjor = version
54 | .split('.')
55 | .next()
56 | .ok_or_else(|| anyhow::anyhow!("Invalid version format"))?;
57 | let manjor: usize = manjor.parse()?;
58 | let minor = version
59 | .split('.')
60 | .nth(1)
61 | .ok_or_else(|| anyhow::anyhow!("Invalid version format"))?;
62 | let minor: usize = minor.parse()?;
63 | let patch = version
64 | .split('.')
65 | .nth(2)
66 | .ok_or_else(|| anyhow::anyhow!("Invalid version format"))?;
67 | let patch: usize = patch.parse()?;
68 |
69 | // Version code rule: Major * 100000 + Minor * 1000 + Patch
70 | Ok(manjor * 100000 + minor * 1000 + patch)
71 | }
72 |
73 | fn update() -> Result<()> {
74 | let toml = fs::read_to_string("Cargo.toml")?;
75 | let data: CargoConfig = toml::from_str(&toml)?;
76 |
77 | //build()?;
78 |
79 | let json = UpdateJson {
80 | versioncode: cal_version_code(&data.package.version)?,
81 | // Fixed typo here as well
82 | version: data.package.version.clone(),
83 | zipurl: format!(
84 | "https://github.com/Tools-cx-app/meta-magic_mount/releases/download/v{}/magic_mount_rs.zip",
85 | data.package.version.clone()
86 | ),
87 | changelog: String::from(
88 | "https://github.com/Tools-cx-app/meta-magic_mount/raw/master/update/changelog.md",
89 | ),
90 | };
91 |
92 | let raw_json = serde_json::to_string_pretty(&json)?;
93 |
94 | fs::write("update/update.json", raw_json)?;
95 |
96 | Ok(())
97 | }
98 |
99 | fn build() -> Result<()> {
100 | let temp_dir = temp_dir();
101 |
102 | let _ = fs::remove_dir_all(&temp_dir);
103 | fs::create_dir_all(&temp_dir)?;
104 |
105 | build_webui()?;
106 |
107 | let mut cargo = cargo_ndk();
108 | let args = vec![
109 | "build",
110 | "--target",
111 | "aarch64-linux-android",
112 | "-Z",
113 | "build-std",
114 | "-Z",
115 | "trim-paths",
116 | "-r",
117 | ];
118 |
119 | cargo.args(args);
120 |
121 | cargo.spawn()?.wait()?;
122 |
123 | let module_dir = module_dir();
124 | dir::copy(
125 | &module_dir,
126 | &temp_dir,
127 | &dir::CopyOptions::new().overwrite(true).content_only(true),
128 | )
129 | .unwrap();
130 |
131 | if temp_dir.join(".gitignore").exists() {
132 | fs::remove_file(temp_dir.join(".gitignore")).unwrap();
133 | }
134 |
135 | file::copy(
136 | bin_path(),
137 | temp_dir.join("magic_mount_rs"),
138 | &file::CopyOptions::new().overwrite(true),
139 | )?;
140 |
141 | let options: FileOptions<'_, ()> = FileOptions::default()
142 | .compression_method(CompressionMethod::Deflated)
143 | .compression_level(Some(9));
144 | zip_create_from_directory_with_options(
145 | &Path::new("output").join("magic_mount_rs.zip"),
146 | &temp_dir,
147 | |_| options,
148 | )
149 | .unwrap();
150 |
151 | Ok(())
152 | }
153 |
154 | fn module_dir() -> PathBuf {
155 | Path::new("module").to_path_buf()
156 | }
157 |
158 | fn temp_dir() -> PathBuf {
159 | Path::new("output").join(".temp")
160 | }
161 |
162 | fn bin_path() -> PathBuf {
163 | Path::new("target")
164 | .join("aarch64-linux-android")
165 | .join("release")
166 | .join("magic_mount_rs")
167 | }
168 | fn cargo_ndk() -> Command {
169 | let mut command = Command::new("cargo");
170 | command
171 | .args(["+nightly", "ndk", "--platform", "31", "-t", "arm64-v8a"])
172 | .env("RUSTFLAGS", "-C default-linker-libraries")
173 | .env("CARGO_CFG_BPF_TARGET_ARCH", "aarch64");
174 | command
175 | }
176 |
177 | fn build_webui() -> Result<()> {
178 | let npm = || {
179 | let mut command = Command::new("npm");
180 | command.current_dir("webui");
181 | command
182 | };
183 |
184 | npm().arg("install").spawn()?.wait()?;
185 | npm().args(["run", "build"]).spawn()?.wait()?;
186 |
187 | Ok(())
188 | }
189 |
--------------------------------------------------------------------------------
/webui/src/routes/ModulesTab.svelte:
--------------------------------------------------------------------------------
1 |
43 |
44 |
45 |
46 |
49 |
50 | {store.L.modules?.desc || "Modules are strictly managed by Magic Mount strategy."}
51 |
52 |
53 |
54 |
64 |
65 | {#if store.loading.modules}
66 |
67 | {#each Array(5) as _}
68 |
69 |
70 |
71 |
72 | {/each}
73 |
74 | {:else if filteredModules.length === 0}
75 |
76 |
79 |
{store.modules.length === 0 ? (store.L.modules?.empty || "No modules found") : "No matching modules"}
80 |
81 | {:else}
82 |
83 | {#each filteredModules as mod (mod.id)}
84 |
89 |
toggleExpand(mod.id)}
92 | onkeydown={(e) => handleKeydown(e, mod.id)}
93 | role="button"
94 | tabindex="0"
95 | >
96 |
97 |
98 |
{mod.name}
99 |
100 | {mod.id}
101 | {mod.version}
102 |
103 |
104 |
105 |
106 | {mod.is_mounted ? 'Magic' : 'Skipped'}
107 |
108 |
109 |
110 | {#if expandedId === mod.id}
111 |
112 |
113 | Author
114 | {mod.author || 'Unknown'}
115 |
116 |
117 |
Description
118 |
{mod.description || 'No description'}
119 |
120 |
121 | {#if !mod.is_mounted}
122 |
123 |
124 |
125 | {#if mod.disabledByFlag}
126 | Disabled via Manager or 'disable' file.
127 | {:else if mod.skipMount}
128 | Skipped via 'skip_mount' flag.
129 | {:else}
130 | Not mounted.
131 | {/if}
132 |
133 |
134 | {/if}
135 |
136 | {/if}
137 |
138 | {/each}
139 |
140 | {/if}
141 |
105 |
106 |
113 |
114 |
126 |
127 |
128 |
{store.L.info.contributors}
129 |
130 | {#if loading}
131 | {#each Array(3) as _}
132 |
133 |
134 |
135 |
136 |
137 |
138 |
139 | {/each}
140 | {:else if error}
141 |
142 | {store.L.info.loadFail}
143 |
144 | {:else}
145 |
146 | {#each contributors as user}
147 | handleLink(e, user.html_url)}
152 | role="link"
153 | tabindex="0"
154 | onkeydown={(e: KeyboardEvent) => { if (e.key === 'Enter' || e.key === ' ') handleLink(e, user.html_url); }}
155 | >
156 | 
157 | {user.name || user.login}
158 | {user.bio || store.L.info.noBio}
159 |
160 | {/each}
161 |
162 | {/if}
163 |
164 |
165 |
94 |
95 |
104 |
105 |
106 |
107 |
113 |
114 |
115 |
116 |
117 |
118 |
124 |
125 |
126 |
127 |
128 | {#if store.loading.logs && !autoRefresh && filteredLogs.length === 0}
129 |
130 | {#each Array(10) as _, i}
131 |
132 | {/each}
133 |
134 | {:else if filteredLogs.length === 0}
135 |
136 | {store.logs.length === 0 ? store.L.logs.empty : "No matching logs"}
137 |
138 | {:else}
139 | {#each filteredLogs as line}
140 |
141 | {#if typeof line === 'string'}
142 | {line}
143 | {:else}
144 | {line.text}
145 | {/if}
146 |
147 | {/each}
148 |
151 | {/if}
152 |
153 | {#if userHasScrolledUp}
154 |
162 | {/if}
163 |
164 |
{store.L.common?.rebootTitle || "Reboot System?"}
46 |
47 | {store.L.common?.rebootConfirm || "Are you sure you want to reboot the device?"}
48 |
49 |
50 | showRebootConfirm = false}
52 | role="button" tabindex="0" onkeydown={() => {}}
53 | >
54 | {store.L.common?.cancel || "Cancel"}
55 |
56 | {}}
59 | >
60 | {store.L.common?.reboot || "Reboot"}
61 |
62 |
63 |
64 |
65 |
66 |
67 |
72 |
73 |
74 |
75 |
78 |
{store.L.status.deviceTitle || "Device"}
79 |
80 |
81 | {#if store.loading.status}
82 |
83 |
84 | {:else}
85 |
{store.device.model}
86 |
87 | Magic Mount v{store.version}
88 |
89 | {/if}
90 |
91 |
92 |
93 |
{ if (e.key === 'Enter' || e.key === ' ') copyDebugInfo(); }}
99 | >
100 |
101 |
102 |
103 |
104 |
105 |
106 |
107 | {#if store.loading.status}
108 |
109 |
110 | {:else}
111 |
{mountedCount}
112 |
{store.L.status.moduleActive}
113 | {/if}
114 |
115 |
116 |
117 | {#if store.loading.status}
118 |
119 |
120 | {:else}
121 |
{store.config?.mountsource ?? '-'}
122 |
{store.L.config.mountSource}
123 | {/if}
124 |
125 |
126 |
127 |
128 |
{store.L.status.sysInfoTitle || "System Details"}
129 |
130 |
131 | {store.L.status.androidLabel || "Android"}
132 | {#if store.loading.status}
133 |
134 | {:else}
135 | {store.device.android}
136 | {/if}
137 |
138 |
139 |
140 | {store.L.status.selinuxLabel || "SELinux"}
141 | {#if store.loading.status}
142 |
143 | {:else}
144 |
145 | {store.device.selinux}
146 |
147 | {/if}
148 |
149 |
150 |
151 | {store.L.status.kernelLabel || "Kernel"}
152 | {#if store.loading.status}
153 |
154 | {:else}
155 | {store.device.kernel}
156 | {/if}
157 |
158 |
159 |
160 |
60 |
109 |
110 |
111 |
112 |
121 |
122 |
123 |
124 |
126 |
127 |
128 |
129 |
144 |
145 |
160 |
161 |
176 |
177 |
179 |
(path: P, node: &Node) -> Result<(Metadata, PathBuf)>
20 | where
21 | P: AsRef,
22 | {
23 | let path = path.as_ref();
24 | if path.exists() {
25 | Ok((path.metadata()?, path.to_path_buf()))
26 | } else if let Some(module_path) = &node.module_path {
27 | Ok((module_path.metadata()?, module_path.clone()))
28 | } else {
29 | bail!("cannot mount root dir {}!", path.display());
30 | }
31 | }
32 |
33 | pub fn tmpfs_skeleton(path: P, work_dir_path: P, node: &Node) -> Result<()>
34 | where
35 | P: AsRef,
36 | {
37 | let (path, work_dir_path) = (path.as_ref(), work_dir_path.as_ref());
38 | log::debug!(
39 | "creating tmpfs skeleton for {} at {}",
40 | path.display(),
41 | work_dir_path.display()
42 | );
43 |
44 | create_dir_all(work_dir_path)?;
45 |
46 | let (metadata, path) = metadata_path(path, node)?;
47 |
48 | chmod(work_dir_path, Mode::from_raw_mode(metadata.mode()))?;
49 | chown(
50 | work_dir_path,
51 | Some(Uid::from_raw(metadata.uid())),
52 | Some(Gid::from_raw(metadata.gid())),
53 | )?;
54 | lsetfilecon(work_dir_path, lgetfilecon(path)?.as_str())?;
55 |
56 | Ok(())
57 | }
58 |
59 | pub fn mount_mirror(path: P, work_dir_path: P, entry: &DirEntry) -> Result<()>
60 | where
61 | P: AsRef,
62 | {
63 | let path = path.as_ref().join(entry.file_name());
64 | let work_dir_path = work_dir_path.as_ref().join(entry.file_name());
65 | let file_type = entry.file_type()?;
66 |
67 | if file_type.is_file() {
68 | log::debug!(
69 | "mount mirror file {} -> {}",
70 | path.display(),
71 | work_dir_path.display()
72 | );
73 | fs::File::create(&work_dir_path)?;
74 | mount_bind(&path, &work_dir_path)?;
75 | } else if file_type.is_dir() {
76 | log::debug!(
77 | "mount mirror dir {} -> {}",
78 | path.display(),
79 | work_dir_path.display()
80 | );
81 | create_dir(&work_dir_path)?;
82 | let metadata = entry.metadata()?;
83 | chmod(&work_dir_path, Mode::from_raw_mode(metadata.mode()))?;
84 | chown(
85 | &work_dir_path,
86 | Some(Uid::from_raw(metadata.uid())),
87 | Some(Gid::from_raw(metadata.gid())),
88 | )?;
89 | lsetfilecon(&work_dir_path, lgetfilecon(&path)?.as_str())?;
90 | for entry in path.read_dir()?.flatten() {
91 | mount_mirror(&path, &work_dir_path, &entry)?;
92 | }
93 | } else if file_type.is_symlink() {
94 | log::debug!(
95 | "create mirror symlink {} -> {}",
96 | path.display(),
97 | work_dir_path.display()
98 | );
99 | clone_symlink(&path, &work_dir_path)?;
100 | }
101 |
102 | Ok(())
103 | }
104 |
105 | pub fn check_tmpfs(node: &mut Node, path: P) -> (Node, bool)
106 | where
107 | P: AsRef,
108 | {
109 | let mut ret_tmpfs = false;
110 | for it in &mut node.children {
111 | let (name, node) = it;
112 | let real_path = path.as_ref().join(name);
113 | let need = match node.file_type {
114 | NodeFileType::Symlink => true,
115 | NodeFileType::Whiteout => real_path.exists(),
116 | _ => {
117 | if let Ok(metadata) = real_path.symlink_metadata() {
118 | let file_type = NodeFileType::from(metadata.file_type());
119 | file_type != node.file_type || file_type == NodeFileType::Symlink
120 | } else {
121 | // real path not exists
122 | true
123 | }
124 | }
125 | };
126 | if need {
127 | if node.module_path.is_none() {
128 | log::error!(
129 | "cannot create tmpfs on {}, ignore: {name}",
130 | path.as_ref().display()
131 | );
132 | node.skip = true;
133 | continue;
134 | }
135 | ret_tmpfs = true;
136 | break;
137 | }
138 | }
139 |
140 | (node.clone(), ret_tmpfs)
141 | }
142 |
143 | pub fn collect_module_files(
144 | module_dir: &Path,
145 | extra_partitions: &[String],
146 | ) -> Result> {
147 | let mut root = Node::new_root("");
148 | let mut system = Node::new_root("system");
149 | let module_root = module_dir;
150 | let mut has_file = false;
151 |
152 | for entry in module_root.read_dir()?.flatten() {
153 | if !entry.file_type()?.is_dir() {
154 | continue;
155 | }
156 |
157 | let prop = entry.path().join("module.prop");
158 | if !prop.exists() {
159 | continue;
160 | }
161 | let string = fs::read_to_string(prop)?;
162 | for line in string.lines() {
163 | if line.starts_with("id")
164 | && let Some((_, value)) = line.split_once('=')
165 | {
166 | validate_module_id(value)?;
167 | }
168 | }
169 |
170 | if entry.path().join(DISABLE_FILE_NAME).exists()
171 | || entry.path().join(REMOVE_FILE_NAME).exists()
172 | || entry.path().join(SKIP_MOUNT_FILE_NAME).exists()
173 | {
174 | continue;
175 | }
176 |
177 | let mod_system = entry.path().join("system");
178 | if !mod_system.is_dir() {
179 | continue;
180 | }
181 |
182 | log::debug!("collecting {}", entry.path().display());
183 |
184 | has_file |= system.collect_module_files(&mod_system)?;
185 | }
186 |
187 | if has_file {
188 | const BUILTIN_PARTITIONS: [(&str, bool); 4] = [
189 | ("vendor", true),
190 | ("system_ext", true),
191 | ("product", true),
192 | ("odm", false),
193 | ];
194 |
195 | for (partition, require_symlink) in BUILTIN_PARTITIONS {
196 | let path_of_root = Path::new("/").join(partition);
197 | let path_of_system = Path::new("/system").join(partition);
198 | if path_of_root.is_dir() && (!require_symlink || path_of_system.is_symlink()) {
199 | let name = partition.to_string();
200 | if let Some(node) = system.children.remove(&name) {
201 | root.children.insert(name, node);
202 | }
203 | }
204 | }
205 |
206 | for partition in extra_partitions {
207 | if BUILTIN_PARTITIONS.iter().any(|(p, _)| p == partition) {
208 | continue;
209 | }
210 | if partition == "system" {
211 | continue;
212 | }
213 |
214 | let path_of_root = Path::new("/").join(partition);
215 | let path_of_system = Path::new("/system").join(partition);
216 | let require_symlink = false;
217 |
218 | if path_of_root.is_dir() && (!require_symlink || path_of_system.is_symlink()) {
219 | let name = partition.clone();
220 | if let Some(node) = system.children.remove(&name) {
221 | log::debug!("attach extra partition '{name}' to root");
222 | root.children.insert(name, node);
223 | }
224 | }
225 | }
226 |
227 | root.children.insert("system".to_string(), system);
228 | Ok(Some(root))
229 | } else {
230 | Ok(None)
231 | }
232 | }
233 |
234 | pub fn clone_symlink(src: S, dst: S) -> Result<()>
235 | where
236 | S: AsRef,
237 | {
238 | let src_symlink = read_link(src.as_ref())?;
239 | symlink(&src_symlink, dst.as_ref())?;
240 | lsetfilecon(dst.as_ref(), lgetfilecon(src.as_ref())?.as_str())?;
241 | log::debug!(
242 | "clone symlink {} -> {}({})",
243 | dst.as_ref().display(),
244 | dst.as_ref().display(),
245 | src_symlink.display()
246 | );
247 | Ok(())
248 | }
249 |
--------------------------------------------------------------------------------
/webui/src/lib/store.svelte.ts:
--------------------------------------------------------------------------------
1 | import { API, type MagicConfig, type MagicModule, type DeviceStatus, type StorageUsage, type SystemInfo } from './api';
2 | import { DEFAULT_CONFIG, DEFAULT_SEED } from './constants';
3 | import { Monet } from './theme';
4 |
5 | const localeModules = import.meta.glob('../locales/*.json', { eager: true });
6 | const modulesAny: Record = localeModules;
7 |
8 | let darkModeQuery: MediaQueryList;
9 |
10 | export interface LogEntry {
11 | text: string;
12 | type: 'info' | 'error' | 'warn' | 'debug';
13 | }
14 |
15 | const createStore = () => {
16 | let theme = $state('auto');
17 | let isSystemDark = $state(false);
18 | let lang = $state('en');
19 | let seed = $state(DEFAULT_SEED);
20 | let loadedLocale = $state(null);
21 | let toast = $state({ id: 'init', text: '', type: 'info', visible: false });
22 |
23 | let fixBottomNav = $state(false);
24 |
25 | const availableLanguages = Object.entries(modulesAny).map(([path, moduleData]) => {
26 | const mod = moduleData as any;
27 | const match = path.match(/\/([^/]+)\.json$/);
28 | const code = match ? match[1] : 'en';
29 | const name = mod.default?.lang?.display || code.toUpperCase();
30 | return { code, name };
31 | }).sort((a, b) => {
32 | if (a.code === 'en') return -1;
33 | if (b.code === 'en') return 1;
34 | return a.name.localeCompare(b.name);
35 | });
36 |
37 | let config = $state(DEFAULT_CONFIG);
38 | let modules = $state([]);
39 | let logs = $state([]);
40 |
41 | let device = $state({ model: '-', android: '-', kernel: '-', selinux: '-' });
42 | let version = $state('...');
43 | let storage = $state({ used: '-', size: '-', percent: '0%', type: null, hymofs_available: false });
44 | let systemInfo = $state({ kernel: '-', selinux: '-', mountBase: '-', activeMounts: [] });
45 | let activePartitions = $state([]);
46 | let diagnostics = $state([]);
47 |
48 | let loadingConfig = $state(false);
49 | let loadingModules = $state(false);
50 | let loadingLogs = $state(false);
51 | let loadingStatus = $state(false);
52 | let loadingDiagnostics = $state(false);
53 |
54 | let savingConfig = $state(false);
55 | let savingModules = $state(false);
56 |
57 | let L = $derived(loadedLocale?.default || {});
58 |
59 | let modeStats = $derived.by(() => {
60 | const stats = { auto: 0, magic: 0, hymofs: 0 };
61 | modules.forEach(m => {
62 | if (!m.is_mounted) return;
63 | stats.magic++;
64 | });
65 | return stats;
66 | });
67 |
68 | function showToast(text: string, type = 'info') {
69 | const id = Date.now().toString();
70 | toast = { id, text, type, visible: true };
71 | setTimeout(() => {
72 | if (toast.id === id) {
73 | toast.visible = false;
74 | }
75 | }, 3000);
76 | }
77 |
78 | function setTheme(t: string) {
79 | theme = t;
80 | localStorage.setItem('mm-theme', t);
81 | applyTheme();
82 | }
83 |
84 | function toggleBottomNavFix() {
85 | fixBottomNav = !fixBottomNav;
86 | localStorage.setItem('mm-fix-nav', String(fixBottomNav));
87 | }
88 |
89 | function applyTheme() {
90 | const isDark = theme === 'auto' ? isSystemDark : theme === 'dark';
91 | document.documentElement.setAttribute('data-theme', isDark ? 'dark' : 'light');
92 | Monet.apply(seed, isDark);
93 | }
94 |
95 | async function loadLocale(code: string) {
96 | const path = `../locales/${code}.json`;
97 | const entry = Object.entries(modulesAny).find(([k]) => k.endsWith(`/${code}.json`));
98 | if (entry) {
99 | loadedLocale = entry[1];
100 | } else {
101 | const enEntry = Object.entries(modulesAny).find(([k]) => k.endsWith('/en.json'));
102 | if (enEntry) loadedLocale = enEntry[1];
103 | }
104 | }
105 |
106 | function setLang(code: string) {
107 | lang = code;
108 | localStorage.setItem('mm-lang', code);
109 | loadLocale(code);
110 | }
111 |
112 | async function init() {
113 | const savedLang = localStorage.getItem('mm-lang') || 'en';
114 | lang = savedLang;
115 | await loadLocale(savedLang);
116 |
117 | const savedTheme = localStorage.getItem('mm-theme');
118 | if (savedTheme) {
119 | theme = savedTheme;
120 | }
121 |
122 | const savedNavFix = localStorage.getItem('mm-fix-nav');
123 | if (savedNavFix === 'true') {
124 | fixBottomNav = true;
125 | }
126 |
127 | if (!darkModeQuery && typeof window !== 'undefined') {
128 | darkModeQuery = window.matchMedia('(prefers-color-scheme: dark)');
129 | isSystemDark = darkModeQuery.matches;
130 | darkModeQuery.addEventListener('change', (e) => {
131 | isSystemDark = e.matches;
132 | applyTheme();
133 | });
134 | }
135 |
136 | try {
137 | const sysColor = await API.fetchSystemColor();
138 | if (sysColor) {
139 | seed = sysColor;
140 | }
141 | } catch {}
142 |
143 | applyTheme();
144 |
145 | await Promise.all([
146 | loadConfig(),
147 | loadStatus()
148 | ]);
149 | }
150 |
151 | async function loadConfig() {
152 | loadingConfig = true;
153 | try {
154 | config = await API.loadConfig();
155 | } catch (e) {
156 | showToast('Failed to load config', 'error');
157 | }
158 | loadingConfig = false;
159 | }
160 |
161 | async function resetConfig() {
162 | loadingConfig = true;
163 | try {
164 | config = { ...DEFAULT_CONFIG };
165 | await saveConfig();
166 | showToast(L.common?.resetSuccess || 'Config Reset', 'success');
167 | } catch(e) {
168 | showToast(L.common?.resetFailed || 'Failed to reset', 'error');
169 | }
170 | loadingConfig = false;
171 | }
172 |
173 | async function saveConfig() {
174 | savingConfig = true;
175 | try {
176 | await API.saveConfig($state.snapshot(config));
177 | showToast(L.common?.saveSuccess || 'Saved', 'success');
178 | } catch (e) {
179 | showToast('Failed to save config', 'error');
180 | }
181 | savingConfig = false;
182 | }
183 |
184 | async function loadModules() {
185 | loadingModules = true;
186 | try {
187 | modules = await API.scanModules(config.moduledir);
188 | } catch (e) {
189 | showToast('Failed to load modules', 'error');
190 | }
191 | loadingModules = false;
192 | }
193 |
194 | async function saveModules() {
195 | showToast("Not supported in this version", "info");
196 | }
197 |
198 | async function loadLogs(silent = false) {
199 | if (!silent) loadingLogs = true;
200 | try {
201 | const rawLogs = await API.readLogs();
202 | logs = rawLogs.split('\n').map((line: string) => {
203 | let type: LogEntry['type'] = 'info';
204 | if (line.includes('[E]') || line.includes('ERROR')) type = 'error';
205 | else if (line.includes('[W]') || line.includes('WARN')) type = 'warn';
206 | else if (line.includes('[D]') || line.includes('DEBUG')) type = 'debug';
207 | return { text: line, type };
208 | });
209 | } catch (e) {
210 | logs = [{ text: "Failed to load logs.", type: 'error' }];
211 | }
212 | loadingLogs = false;
213 | }
214 |
215 | async function loadStatus() {
216 | loadingStatus = true;
217 | loadingDiagnostics = true;
218 | try {
219 | const baseDevice = await API.getDeviceStatus();
220 | version = await API.getVersion();
221 | storage = await API.getStorageUsage();
222 | systemInfo = await API.getSystemInfo();
223 | activePartitions = systemInfo.activeMounts || [];
224 | diagnostics = [];
225 |
226 | device = {
227 | ...baseDevice,
228 | kernel: systemInfo.kernel,
229 | selinux: systemInfo.selinux
230 | };
231 |
232 | if (modules.length === 0) {
233 | await loadModules();
234 | }
235 | } catch (e) {}
236 | loadingStatus = false;
237 | loadingDiagnostics = false;
238 | }
239 |
240 | async function rebootDevice() {
241 | try {
242 | await API.reboot();
243 | } catch(e) {
244 | showToast(L.common?.rebootFailed || 'Reboot failed', 'error');
245 | }
246 | }
247 |
248 | return {
249 | get theme() { return theme; },
250 | get isSystemDark() { return isSystemDark; },
251 | get lang() { return lang; },
252 | get seed() { return seed; },
253 | get availableLanguages() { return availableLanguages; },
254 | get L() { return L; },
255 | get toast() { return toast; },
256 | get toasts() { return toast.visible ? [toast] : []; },
257 | showToast,
258 | setTheme,
259 | setLang,
260 | init,
261 |
262 | get fixBottomNav() { return fixBottomNav; },
263 | toggleBottomNavFix,
264 |
265 | get config() { return config; },
266 | set config(v) { config = v; },
267 | loadConfig,
268 | saveConfig,
269 | resetConfig,
270 |
271 | get modules() { return modules; },
272 | set modules(v) { modules = v; },
273 | get modeStats() { return modeStats; },
274 | loadModules,
275 | saveModules,
276 |
277 | get logs() { return logs; },
278 | loadLogs,
279 |
280 | get device() { return device; },
281 | get version() { return version; },
282 | get storage() { return storage; },
283 | get systemInfo() { return systemInfo; },
284 | get activePartitions() { return activePartitions; },
285 | get diagnostics() { return diagnostics; },
286 | loadStatus,
287 | rebootDevice,
288 |
289 | get loading() {
290 | return {
291 | config: loadingConfig,
292 | modules: loadingModules,
293 | logs: loadingLogs,
294 | status: loadingStatus,
295 | diagnostics: loadingDiagnostics
296 | };
297 | },
298 | get saving() {
299 | return {
300 | config: savingConfig,
301 | modules: savingModules
302 | };
303 | }
304 | };
305 | };
306 |
307 | export const store = createStore();
--------------------------------------------------------------------------------
/webui/src/lib/api.ts:
--------------------------------------------------------------------------------
1 | import { DEFAULT_CONFIG, PATHS } from './constants';
2 | import { MockAPI } from './api.mock';
3 |
4 | export interface MagicConfig {
5 | moduledir: string;
6 | tempdir?: string;
7 | mountsource: string;
8 | verbose: boolean;
9 | umount: boolean;
10 | disable_umount?: boolean;
11 | partitions: string[];
12 | [key: string]: any;
13 | }
14 |
15 | export interface MagicModule {
16 | id: string;
17 | name: string;
18 | version: string;
19 | author: string;
20 | description: string;
21 | is_mounted: boolean;
22 | mode: string;
23 | disabledByFlag?: boolean;
24 | skipMount?: boolean;
25 | rules: { default_mode: string; paths: Record };
26 | }
27 |
28 | export interface SystemInfo {
29 | kernel: string;
30 | selinux: string;
31 | mountBase: string;
32 | activeMounts: string[];
33 | }
34 |
35 | export interface StorageUsage {
36 | type: string | null;
37 | percent: string;
38 | size: string;
39 | used: string;
40 | hymofs_available: boolean;
41 | }
42 |
43 | export interface DeviceStatus {
44 | model: string;
45 | android: string;
46 | kernel: string;
47 | selinux: string;
48 | }
49 |
50 | interface KsuExecResult {
51 | errno: number;
52 | stdout: string;
53 | stderr: string;
54 | }
55 | type KsuExec = (cmd: string) => Promise;
56 |
57 | let ksuExec: KsuExec | null = null;
58 |
59 | try {
60 | // @ts-ignore
61 | const ksu = await import('kernelsu').catch(() => null);
62 | ksuExec = ksu ? ksu.exec : null;
63 | } catch (e) {
64 | console.warn("KernelSU module not found, defaulting to Mock.");
65 | }
66 |
67 | const shouldUseMock = import.meta.env.DEV || !ksuExec;
68 | console.log(`[API Init] Mode: ${shouldUseMock ? '🛠️ MOCK' : '🚀 REAL'}`);
69 |
70 | function isTrueValue(v: any): boolean {
71 | const s = String(v).trim().toLowerCase();
72 | return s === '1' || s === 'true' || s === 'yes' || s === 'on';
73 | }
74 |
75 | function stripQuotes(v: string): string {
76 | if (v.startsWith('"') && v.endsWith('"')) {
77 | return v.slice(1, -1);
78 | }
79 | return v;
80 | }
81 |
82 | function parseKvConfig(text: string): MagicConfig {
83 | try {
84 | const result: MagicConfig = { ...DEFAULT_CONFIG };
85 | const lines = text.split('\n');
86 | for (let line of lines) {
87 | line = line.trim();
88 | if (!line || line.startsWith('#')) continue;
89 | const eqIndex = line.indexOf('=');
90 | if (eqIndex < 0) continue;
91 | let key = line.slice(0, eqIndex).trim();
92 | let value = line.slice(eqIndex + 1).trim();
93 | if (!key || !value) continue;
94 |
95 | if (value.startsWith('[') && value.endsWith(']')) {
96 | value = value.slice(1, -1);
97 | if (!value.trim()) {
98 | if (key === 'partitions') result.partitions = [];
99 | continue;
100 | }
101 | const parts = value.split(',').map(s => stripQuotes(s.trim()));
102 | if (key === 'partitions') result.partitions = parts;
103 | continue;
104 | }
105 |
106 | const rawValue = value;
107 | value = stripQuotes(value);
108 |
109 | switch (key) {
110 | case 'moduledir': result.moduledir = value; break;
111 | case 'tempdir': result.tempdir = value; break;
112 | case 'mountsource': result.mountsource = value; break;
113 | case 'verbose': result.verbose = isTrueValue(rawValue); break;
114 | case 'umount': result.umount = isTrueValue(rawValue); break;
115 | }
116 | }
117 | return result;
118 | } catch (e) {
119 | console.error('Failed to parse config:', e);
120 | return DEFAULT_CONFIG;
121 | }
122 | }
123 |
124 | function serializeKvConfig(cfg: MagicConfig): string {
125 | const q = (s: string) => `"${s}"`;
126 | const lines = ['# Magic Mount Configuration File', ''];
127 | lines.push(`moduledir = ${q(cfg.moduledir)}`);
128 | if (cfg.tempdir) lines.push(`tempdir = ${q(cfg.tempdir)}`);
129 | lines.push(`mountsource = ${q(cfg.mountsource)}`);
130 | lines.push(`verbose = ${cfg.verbose}`);
131 | lines.push(`umount = ${!cfg.disable_umount}`);
132 | const parts = cfg.partitions.map(p => q(p)).join(', ');
133 | lines.push(`partitions = [${parts}]`);
134 | return lines.join('\n');
135 | }
136 |
137 | function formatBytes(bytes: number, decimals = 2): string {
138 | if (!+bytes) return '0 B';
139 | const k = 1024;
140 | const dm = decimals < 0 ? 0 : decimals;
141 | const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
142 | const i = Math.floor(Math.log(bytes) / Math.log(k));
143 | return `${parseFloat((bytes / Math.pow(k, i)).toFixed(dm))} ${sizes[i]}`;
144 | }
145 |
146 | const RealAPI = {
147 | loadConfig: async (): Promise => {
148 | try {
149 | const { errno, stdout } = await ksuExec!(`[ -f "${PATHS.CONFIG}" ] && cat "${PATHS.CONFIG}" || echo ""`);
150 | if (errno === 0 && stdout.trim()) {
151 | const raw = parseKvConfig(stdout);
152 | return {
153 | ...raw,
154 | disable_umount: !raw.umount,
155 | };
156 | }
157 | } catch (e) {
158 | console.error("Config load error:", e);
159 | }
160 | return { ...DEFAULT_CONFIG, disable_umount: !DEFAULT_CONFIG.umount };
161 | },
162 |
163 | saveConfig: async (config: MagicConfig): Promise => {
164 | const content = serializeKvConfig(config);
165 | const cmd = `
166 | mkdir -p "$(dirname "${PATHS.CONFIG}")"
167 | cat > "${PATHS.CONFIG}" << 'EOF_CONFIG'
168 | ${content}
169 | EOF_CONFIG
170 | chmod 644 "${PATHS.CONFIG}"
171 | `;
172 | const { errno, stderr } = await ksuExec!(cmd);
173 | if (errno !== 0) throw new Error(`Failed to save config: ${stderr}`);
174 | },
175 |
176 | scanModules: async (moduleDir: string): Promise => {
177 | const cmd = `/data/adb/modules/magic_mount_rs/meta-mm scan --json`;
178 | try {
179 | const { errno, stdout, stderr } = await ksuExec!(cmd);
180 | if (errno === 0 && stdout) {
181 | try {
182 | const rawModules = JSON.parse(stdout);
183 | return rawModules.map((m: any) => ({
184 | id: m.id,
185 | name: m.name,
186 | version: m.version,
187 | author: m.author || "Unknown",
188 | description: m.description,
189 | is_mounted: !m.skip,
190 | mode: 'magic',
191 | rules: { default_mode: 'magic', paths: {} }
192 | }));
193 | } catch (parseError) {
194 | console.error("Failed to parse module JSON:", parseError);
195 | return [];
196 | }
197 | } else {
198 | console.error("Scan command failed:", stderr);
199 | }
200 | } catch (e) {
201 | console.error("Scan modules error:", e);
202 | }
203 | return [];
204 | },
205 |
206 | readLogs: async (logPath = PATHS.LOG_FILE, lines = 1000): Promise => {
207 | const cmd = `[ -f "${logPath}" ] && tail -n ${lines} "${logPath}" || echo ""`;
208 | const { errno, stdout, stderr } = await ksuExec!(cmd);
209 | if (errno === 0) return stdout || "";
210 | throw new Error(stderr || "Log file not found");
211 | },
212 |
213 | getStorageUsage: async (): Promise => {
214 | try {
215 | const { stdout } = await ksuExec!(`df -k /data/adb/modules | tail -n 1`);
216 | if (stdout) {
217 | const parts = stdout.split(/\s+/);
218 | if (parts.length >= 6) {
219 | const total = parseInt(parts[1]) * 1024;
220 | const used = parseInt(parts[2]) * 1024;
221 | const percent = parts[4];
222 | return {
223 | type: 'ext4',
224 | percent: percent,
225 | size: formatBytes(total),
226 | used: formatBytes(used),
227 | hymofs_available: false
228 | };
229 | }
230 | }
231 | } catch (e) {}
232 | return { size: '-', used: '-', percent: '0%', type: null, hymofs_available: false };
233 | },
234 |
235 | getSystemInfo: async (): Promise => {
236 | try {
237 | const cmd = `
238 | echo "KERNEL:$(uname -r)"
239 | echo "SELINUX:$(getenforce)"
240 | `;
241 | const { errno, stdout } = await ksuExec!(cmd);
242 | let info = { kernel: '-', selinux: '-', mountBase: '/data/adb/modules', activeMounts: [] as string[] };
243 | if (errno === 0 && stdout) {
244 | stdout.split('\n').forEach(line => {
245 | if (line.startsWith('KERNEL:')) info.kernel = line.substring(7).trim();
246 | else if (line.startsWith('SELINUX:')) info.selinux = line.substring(8).trim();
247 | });
248 | }
249 | const m = await ksuExec!(`ls -1 /data/adb/modules`);
250 | if (m.errno === 0 && m.stdout) {
251 | info.activeMounts = m.stdout.split('\n').filter(s => s.trim() && s !== 'magic_mount_rs');
252 | }
253 | return info;
254 | } catch (e) {
255 | return { kernel: '-', selinux: '-', mountBase: '-', activeMounts: [] };
256 | }
257 | },
258 |
259 | getDeviceStatus: async (): Promise => {
260 | const cmd = `getprop ro.product.model; getprop ro.build.version.release`;
261 | const { stdout } = await ksuExec!(cmd);
262 | const lines = stdout ? stdout.split('\n') : [];
263 | return {
264 | model: lines[0] || 'Unknown',
265 | android: lines[1] || 'Unknown',
266 | kernel: 'See System Info',
267 | selinux: 'See System Info'
268 | };
269 | },
270 |
271 | getVersion: async (): Promise => {
272 | const cmd = `/data/adb/modules/magic_mount_rs/meta-mm version`;
273 | try {
274 | const { errno, stdout } = await ksuExec!(cmd);
275 | if (errno === 0 && stdout) {
276 | const res = JSON.parse(stdout);
277 | return res.version || "0.0.0";
278 | }
279 | } catch (e) {}
280 | return "Unknown";
281 | },
282 |
283 | openLink: async (url: string) => {
284 | const safeUrl = url.replace(/"/g, '\\"');
285 | const cmd = `am start -a android.intent.action.VIEW -d "${safeUrl}"`;
286 | await ksuExec!(cmd);
287 | },
288 |
289 | fetchSystemColor: async (): Promise => {
290 | try {
291 | const { stdout } = await ksuExec!('settings get secure theme_customization_overlay_packages');
292 | if (stdout) {
293 | const match = /["']?android\.theme\.customization\.system_palette["']?\s*:\s*["']?#?([0-9a-fA-F]{6,8})["']?/i.exec(stdout) ||
294 | /["']?source_color["']?\s*:\s*["']?#?([0-9a-fA-F]{6,8})["']?/i.exec(stdout);
295 | if (match && match[1]) {
296 | let hex = match[1];
297 | if (hex.length === 8) hex = hex.substring(2);
298 | return '#' + hex;
299 | }
300 | }
301 | } catch (e) {}
302 | return null;
303 | },
304 |
305 | reboot: async (): Promise => {
306 | const cmd = 'svc power reboot || reboot';
307 | await ksuExec!(cmd);
308 | }
309 | };
310 |
311 | if (MockAPI && !MockAPI.reboot) {
312 | MockAPI.reboot = async () => { console.log("Mock Reboot triggered"); };
313 | }
314 |
315 | export const API = shouldUseMock ? MockAPI : RealAPI;
--------------------------------------------------------------------------------
/src/magic_mount/mod.rs:
--------------------------------------------------------------------------------
1 | mod node;
2 | mod utils;
3 |
4 | use std::{
5 | fs,
6 | path::{Path, PathBuf},
7 | };
8 |
9 | use anyhow::{Context, Result, bail};
10 | use rustix::mount::{
11 | MountFlags, MountPropagationFlags, UnmountFlags, mount, mount_bind, mount_change, mount_move,
12 | mount_remount, unmount,
13 | };
14 |
15 | #[cfg(any(target_os = "linux", target_os = "android"))]
16 | use crate::try_umount::send_unmountable;
17 | use crate::{
18 | magic_mount::{
19 | node::{Node, NodeFileType},
20 | utils::{clone_symlink, collect_module_files, mount_mirror},
21 | },
22 | utils::ensure_dir_exists,
23 | };
24 |
25 | struct MagicMount {
26 | node: Node,
27 | path: PathBuf,
28 | work_dir_path: PathBuf,
29 | has_tmpfs: bool,
30 | #[cfg(any(target_os = "linux", target_os = "android"))]
31 | umount: bool,
32 | }
33 |
34 | impl MagicMount {
35 | fn new(
36 | node: &Node,
37 | path: P,
38 | work_dir_path: P,
39 | has_tmpfs: bool,
40 | #[cfg(any(target_os = "linux", target_os = "android"))] umount: bool,
41 | ) -> Self
42 | where
43 | P: AsRef,
44 | {
45 | Self {
46 | node: node.clone(),
47 | path: path.as_ref().join(node.name.clone()),
48 | work_dir_path: work_dir_path.as_ref().join(node.name.clone()),
49 | has_tmpfs,
50 | #[cfg(any(target_os = "linux", target_os = "android"))]
51 | umount,
52 | }
53 | }
54 |
55 | fn do_mount(&mut self) -> Result<()> {
56 | match self.node.file_type {
57 | NodeFileType::Symlink => self.symlink(),
58 | NodeFileType::RegularFile => self.regular_file(),
59 | NodeFileType::Directory => self.directory(),
60 | NodeFileType::Whiteout => {
61 | log::debug!("file {} is removed", self.path.display());
62 | Ok(())
63 | }
64 | }
65 | }
66 | }
67 |
68 | impl MagicMount {
69 | fn symlink(&self) -> Result<()> {
70 | if let Some(module_path) = &self.node.module_path {
71 | log::debug!(
72 | "create module symlink {} -> {}",
73 | module_path.display(),
74 | self.work_dir_path.display()
75 | );
76 | clone_symlink(module_path, &self.work_dir_path).with_context(|| {
77 | format!(
78 | "create module symlink {} -> {}",
79 | module_path.display(),
80 | self.work_dir_path.display(),
81 | )
82 | })?;
83 | Ok(())
84 | } else {
85 | bail!("cannot mount root symlink {}!", self.path.display());
86 | }
87 | }
88 |
89 | fn regular_file(&self) -> Result<()> {
90 | let target = if self.has_tmpfs {
91 | fs::File::create(&self.work_dir_path)?;
92 | &self.work_dir_path
93 | } else {
94 | &self.path
95 | };
96 |
97 | if self.node.module_path.is_none() {
98 | bail!("cannot mount root file {}!", self.path.display());
99 | }
100 |
101 | let module_path = &self.node.module_path.clone().unwrap();
102 |
103 | log::debug!(
104 | "mount module file {} -> {}",
105 | module_path.display(),
106 | self.work_dir_path.display()
107 | );
108 |
109 | mount_bind(module_path, target).with_context(|| {
110 | #[cfg(any(target_os = "linux", target_os = "android"))]
111 | if self.umount {
112 | // tell ksu about this mount
113 | let _ = send_unmountable(target);
114 | }
115 | format!(
116 | "mount module file {} -> {}",
117 | module_path.display(),
118 | self.work_dir_path.display(),
119 | )
120 | })?;
121 |
122 | // we should use MS_REMOUNT | MS_BIND | MS_xxx to change mount flags
123 | if let Err(e) = mount_remount(target, MountFlags::RDONLY | MountFlags::BIND, "") {
124 | log::warn!("make file {} ro: {e:#?}", target.display());
125 | }
126 | Ok(())
127 | }
128 |
129 | fn directory(&mut self) -> Result<()> {
130 | let mut tmpfs = !self.has_tmpfs && self.node.replace && self.node.module_path.is_some();
131 |
132 | if !self.has_tmpfs && !tmpfs {
133 | let (node, ret_tmpfs) = utils::check_tmpfs(&mut self.node, &self.path);
134 | self.node = node;
135 | self.has_tmpfs = ret_tmpfs;
136 | tmpfs = ret_tmpfs;
137 | }
138 | let has_tmpfs = tmpfs || self.has_tmpfs;
139 |
140 | if has_tmpfs {
141 | utils::tmpfs_skeleton(&self.path, &self.work_dir_path, &self.node)?;
142 | }
143 |
144 | if tmpfs {
145 | mount_bind(&self.work_dir_path, &self.work_dir_path).with_context(|| {
146 | format!(
147 | "creating tmpfs for {} at {}",
148 | self.path.display(),
149 | self.work_dir_path.display(),
150 | )
151 | })?;
152 | }
153 |
154 | if self.path.exists() && !self.node.replace {
155 | self.mount_path(has_tmpfs)?;
156 | }
157 |
158 | if self.node.replace {
159 | if self.node.module_path.is_none() {
160 | bail!(
161 | "dir {} is declared as replaced but it is root!",
162 | self.path.display()
163 | );
164 | }
165 |
166 | log::debug!("dir {} is replaced", self.path.display());
167 | }
168 |
169 | for (name, node) in &self.node.children {
170 | if node.skip {
171 | continue;
172 | }
173 |
174 | if let Err(e) = {
175 | Self::new(
176 | node,
177 | &self.path,
178 | &self.work_dir_path,
179 | has_tmpfs,
180 | #[cfg(any(target_os = "linux", target_os = "android"))]
181 | self.umount,
182 | )
183 | .do_mount()
184 | }
185 | .with_context(|| format!("magic mount {}/{name}", self.path.display()))
186 | {
187 | if has_tmpfs {
188 | return Err(e);
189 | }
190 |
191 | log::error!("mount child {}/{name} failed: {e:#?}", self.path.display());
192 | }
193 | }
194 |
195 | if tmpfs {
196 | log::debug!(
197 | "moving tmpfs {} -> {}",
198 | self.work_dir_path.display(),
199 | self.path.display()
200 | );
201 |
202 | if let Err(e) = mount_remount(
203 | &self.work_dir_path,
204 | MountFlags::RDONLY | MountFlags::BIND,
205 | "",
206 | ) {
207 | log::warn!("make dir {} ro: {e:#?}", self.path.display());
208 | }
209 | mount_move(&self.work_dir_path, &self.path).with_context(|| {
210 | format!(
211 | "moving tmpfs {} -> {}",
212 | self.work_dir_path.display(),
213 | self.path.display()
214 | )
215 | })?;
216 | // make private to reduce peer group count
217 | if let Err(e) = mount_change(&self.path, MountPropagationFlags::PRIVATE) {
218 | log::warn!("make dir {} private: {e:#?}", self.path.display());
219 | }
220 |
221 | #[cfg(any(target_os = "linux", target_os = "android"))]
222 | if self.umount {
223 | // tell ksu about this one too
224 | let _ = send_unmountable(&self.path);
225 | }
226 | }
227 | Ok(())
228 | }
229 | }
230 |
231 | impl MagicMount {
232 | fn mount_path(&mut self, has_tmpfs: bool) -> Result<()> {
233 | for entry in self.path.read_dir()?.flatten() {
234 | let name = entry.file_name().to_string_lossy().to_string();
235 | let result = {
236 | if let Some(node) = self.node.children.remove(&name) {
237 | if node.skip {
238 | continue;
239 | }
240 |
241 | Self::new(
242 | &node,
243 | &self.path,
244 | &self.work_dir_path,
245 | has_tmpfs,
246 | #[cfg(any(target_os = "linux", target_os = "android"))]
247 | self.umount,
248 | )
249 | .do_mount()
250 | .with_context(|| format!("magic mount {}/{name}", self.path.display()))
251 | } else if has_tmpfs {
252 | mount_mirror(&self.path, &self.work_dir_path, &entry)
253 | .with_context(|| format!("mount mirror {}/{name}", self.path.display()))
254 | } else {
255 | Ok(())
256 | }
257 | };
258 |
259 | if let Err(e) = result {
260 | if has_tmpfs {
261 | return Err(e);
262 | }
263 | log::error!("mount child {}/{name} failed: {e:#?}", self.path.display());
264 | }
265 | }
266 |
267 | Ok(())
268 | }
269 | }
270 |
271 | pub fn magic_mount(
272 | tmp_path: P,
273 | module_dir: &Path,
274 | mount_source: &str,
275 | extra_partitions: &[String],
276 | #[cfg(any(target_os = "linux", target_os = "android"))] umount: bool,
277 | #[cfg(not(any(target_os = "linux", target_os = "android")))] _umount: bool,
278 | ) -> Result<()>
279 | where
280 | P: AsRef,
281 | {
282 | if let Some(root) = collect_module_files(module_dir, extra_partitions)? {
283 | log::debug!("collected: {root}");
284 | std::thread::Builder::new()
285 | .name("GetTree".to_string())
286 | .spawn(|| -> Result<()> {
287 | let output = std::process::Command::new("busybox")
288 | .args(["tree", "/data/adb/modules"])
289 | .output();
290 |
291 | if output.is_err() {
292 | return Ok(());
293 | }
294 |
295 | let _ = fs::write(
296 | "/data/adb/magic_mount/tree",
297 | String::from_utf8_lossy(&output?.stdout).to_string(),
298 | );
299 |
300 | Ok(())
301 | })?;
302 |
303 | let tmp_root = tmp_path.as_ref();
304 | let tmp_dir = tmp_root.join("workdir");
305 | ensure_dir_exists(&tmp_dir)?;
306 |
307 | mount(mount_source, &tmp_dir, "tmpfs", MountFlags::empty(), None).context("mount tmp")?;
308 | mount_change(&tmp_dir, MountPropagationFlags::PRIVATE).context("make tmp private")?;
309 |
310 | let ret = MagicMount::new(
311 | &root,
312 | Path::new("/"),
313 | tmp_dir.as_path(),
314 | false,
315 | #[cfg(any(target_os = "linux", target_os = "android"))]
316 | umount,
317 | )
318 | .do_mount();
319 |
320 | if let Err(e) = unmount(&tmp_dir, UnmountFlags::DETACH) {
321 | log::error!("failed to unmount tmp {e}");
322 | }
323 | fs::remove_dir(tmp_dir).ok();
324 |
325 | ret
326 | } else {
327 | log::info!("no modules to mount, skipping!");
328 | Ok(())
329 | }
330 | }
331 |
--------------------------------------------------------------------------------