@mmmbuto/masix 0.4.1 → 0.4.3

package/README.md

@@ -1,10 +1,10 @@
 # @mmmbuto/masix
 
-Official Termux package for MasiX (MIT).
+Official npm package for the Termux distribution of MasiX (MIT).
 
-MasiX is a Rust automation runtime optimized for smartphone use in Termux and compatible with Linux and macOS source builds.
+MasiX is Termux-first. Linux and macOS are supported through source builds and the Homebrew tap.
 
-Current package line: `0.4.1`.
+Current package line: `0.4.3`.
 
 ## Function Summary
 
@@ -19,6 +19,7 @@ Current package line: `0.4.1`.
 - Termux boot automation (`masix termux boot enable|disable|status`)
 - Optional local STT via whisper.cpp (`masix config stt`)
 - Bundled `plugin-base` packages are included and installed during `npm install`
+- If a bundled `.pkg` is missing, MasiX can fall back to source build for the module
 - Startup update checks are available on demand via `masix check-update`
 
 ## Install (Termux)
@@ -42,11 +43,11 @@ masix status
 ## Bundled Packages
 
 Postinstall installs these bundled `plugin-base` packages into `~/.masix/plugins`:
-- `discovery` `0.2.4`
+- `discovery` `0.3.0`
 - `codex-backend` `0.1.4`
 - `codex-tools` `0.1.3`
 
-Package artifacts are also included in the npm tarball under `packages/plugin-base/`.
+Package artifacts and source trees are included in the npm tarball under `packages/plugin-base/`.
 
 ## Useful Commands
 
@@ -67,6 +68,7 @@ masix stats
 
 - This package targets Android + arm64 in Termux
 - If no prebuilt binary is available, postinstall builds from source
+- The postinstall step uses `masix plugin install-base` so dependency order and source fallback stay aligned with the CLI
 - `masix config stt` can auto-pick and auto-download a Whisper model based on device resources
 
 ## Full Documentation

package/install.js

@@ -7,31 +7,6 @@ const BINARY_NAME = 'masix';
 const PACKAGE_BIN_PATH = path.join(__dirname, 'prebuilt', BINARY_NAME);
 const PREBUILT_DIR = path.join(__dirname, 'prebuilt');
 const BUNDLED_PACKAGES_DIR = path.join(__dirname, 'packages', 'plugin-base');
-const TERMUX_PLATFORM = 'android-aarch64-termux';
-const BUNDLED_PLUGINS = [
-  {
-    plugin: 'discovery',
-    version: '0.2.4',
-    packageType: 'mcp_binary',
-    file: path.join(BUNDLED_PACKAGES_DIR, 'discovery', '0.2.4', 'discovery-android-aarch64-termux.pkg'),
-    adminOnly: false
-  },
-  {
-    plugin: 'codex-backend',
-    version: '0.1.4',
-    packageType: 'library',
-    file: path.join(BUNDLED_PACKAGES_DIR, 'codex-backend', '0.1.4', 'codex-backend-android-aarch64-termux.pkg'),
-    adminOnly: true
-  },
-  {
-    plugin: 'codex-tools',
-    version: '0.1.3',
-    packageType: 'mcp_binary',
-    file: path.join(BUNDLED_PACKAGES_DIR, 'codex-tools', '0.1.3', 'codex-tools-android-aarch64-termux.pkg'),
-    adminOnly: true
-  }
-];
-
 const isTermux =
   process.env.TERMUX_VERSION !== undefined ||
   process.env.PREFIX === '/data/data/com.termux/files/usr';
@@ -100,32 +75,20 @@ function ensureMasixHome() {
 }
 
 function installBundledPlugins() {
-  for (const plugin of BUNDLED_PLUGINS) {
-    if (!fs.existsSync(plugin.file)) {
-      throw new Error(`Bundled package missing: ${plugin.file}`);
-    }
+  if (!fs.existsSync(BUNDLED_PACKAGES_DIR)) {
+    throw new Error(`Bundled packages root missing: ${BUNDLED_PACKAGES_DIR}`);
+  }
 
-    const args = [
+  execFileSync(
+    PACKAGE_BIN_PATH,
+    [
       'plugin',
-      'install-file',
-      '--file',
-      plugin.file,
-      '--plugin',
-      plugin.plugin,
-      '--version',
-      plugin.version,
-      '--package-type',
-      plugin.packageType,
-      '--platform',
-      TERMUX_PLATFORM
-    ];
-
-    if (plugin.adminOnly) {
-      args.push('--admin-only');
-    }
-
-    execFileSync(PACKAGE_BIN_PATH, args, { stdio: 'inherit' });
-  }
+      'install-base',
+      '--packages-root',
+      BUNDLED_PACKAGES_DIR
+    ],
+    { stdio: 'inherit' }
+  );
 }
 
 ensureBinary();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mmmbuto/masix",
-  "version": "0.4.1",
-  "description": "Termux-first MIT automation runtime (Telegram, MCP, Cron) with bundled plugin-base packages and in-core STT",
+  "version": "0.4.3",
+  "description": "Termux-first MIT automation runtime for Android/Termux; Linux/macOS supported via source builds and Homebrew; bundled plugin-base packages auto-install or auto-build as needed",
   "main": "check-update.js",
   "files": [
     "README.md",

package/packages/plugin-base/discovery/0.2.4/manifest.json

@@ -4,6 +4,8 @@
   "visibility": "plugin-base",
   "license": "MIT",
   "package_type": "mcp_binary",
+  "entrypoint": "masix-plugin-discovery",
+  "dependencies": [],
   "platforms": [
     {
       "id": "android-aarch64-termux",
@@ -21,6 +23,11 @@
       "sha256": "b850b42f50e142e65577a418ecace3fefbec32502dba96c71f82593b37e5a004"
     }
   ],
+  "source": {
+    "git_url": "https://github.com/DioNanos/MasiX.git",
+    "git_ref": "v0.4.2",
+    "subdir": "packages/plugin-base/discovery/source"
+  },
   "install": {
     "command": "masix plugin install-file --file <path-to-pkg> --plugin discovery --version 0.2.4 --package-type mcp_binary"
   },

package/packages/plugin-base/discovery/0.3.0/SHA256SUMS

@@ -0,0 +1,2 @@
+d5180da4bf40e1d751d1a785bad7febba517d37df6be5183176b12ee31523a21  discovery-android-aarch64-termux.pkg
+bfcc03af9258882631d86d5c4eafef613f765ede35b22808d26a6377ff6d3351  discovery-linux-x86_64.pkg

package/packages/plugin-base/discovery/0.3.0/manifest.json

@@ -0,0 +1,34 @@
+{
+  "plugin_id": "discovery",
+  "version": "0.3.0",
+  "visibility": "plugin-base",
+  "license": "MIT",
+  "package_type": "mcp_binary",
+  "entrypoint": "masix-plugin-discovery",
+  "dependencies": [],
+  "platforms": [
+    {
+      "id": "android-aarch64-termux",
+      "file": "discovery-android-aarch64-termux.pkg",
+      "sha256": "d5180da4bf40e1d751d1a785bad7febba517d37df6be5183176b12ee31523a21"
+    },
+    {
+      "id": "linux-x86_64",
+      "file": "discovery-linux-x86_64.pkg",
+      "sha256": "bfcc03af9258882631d86d5c4eafef613f765ede35b22808d26a6377ff6d3351"
+    }
+  ],
+  "source": {
+    "git_url": "https://github.com/DioNanos/MasiX.git",
+    "git_ref": "v0.4.3",
+    "subdir": "packages/plugin-base/discovery/source"
+  },
+  "install": {
+    "command": "masix plugin install-file --file <path-to-pkg> --plugin discovery --version 0.3.0 --package-type mcp_binary"
+  },
+  "notes": [
+    "Package usable without plugin server.",
+    "Tor support is optional and degrades gracefully to clearnet.",
+    "macOS currently relies on bundled source-build fallback until an Apple prebuilt artifact is refreshed."
+  ]
+}

package/packages/plugin-base/discovery/CHANGELOG.md

@@ -1,5 +1,12 @@
 # discovery Package Changelog
 
+## 0.3.0 - 2026-03-21
+
+- Added anti-censorship transport support with Tor auto-detect and graceful clearnet fallback.
+- Expanded SearXNG defaults and added `tor-search` plus `search-status`.
+- Upgraded `torrent-search` with mirror catalog federation, provider filtering, richer metadata, and magnet cache support.
+- Refreshed package artifacts for `linux-x86_64` and `android-aarch64-termux`; macOS currently uses bundled source-build fallback until the Apple prebuilt artifact is refreshed.
+
 ## 0.2.4 - 2026-03-05
 
 - Refreshed package artifacts for android-aarch64-termux, linux-x86_64, macos-aarch64.

package/packages/plugin-base/discovery/README.md

@@ -1,12 +1,14 @@
 # discovery (`plugin-base`)
 
-`discovery` provides MCP discovery and fetch tools bundled with the MIT repository.
+`discovery` provides MCP discovery, fetch, torrent metadata, and anti-censorship search tools bundled with the MIT repository.
 
 ## What It Is
 
 - Package type: `mcp_binary`
 - Visibility: `plugin-base`
 - Distribution: local `.pkg` install supported (`install-file`)
+- Tor: optional, graceful fallback to clearnet
+- Status tool: `search-status`
 
 ## Install Example
 
@@ -14,9 +16,9 @@ Termux:
 
 ```bash
 masix plugin install-file \
-  --file packages/plugin-base/discovery/0.2.4/discovery-android-aarch64-termux.pkg \
+  --file packages/plugin-base/discovery/0.3.0/discovery-android-aarch64-termux.pkg \
   --plugin discovery \
-  --version 0.2.4 \
+  --version 0.3.0 \
   --package-type mcp_binary
 ```
 
@@ -24,25 +26,32 @@ Linux:
 
 ```bash
 masix plugin install-file \
-  --file packages/plugin-base/discovery/0.2.4/discovery-linux-x86_64.pkg \
+  --file packages/plugin-base/discovery/0.3.0/discovery-linux-x86_64.pkg \
   --plugin discovery \
-  --version 0.2.4 \
+  --version 0.3.0 \
   --package-type mcp_binary
 ```
 
 macOS (Apple Silicon):
 
 ```bash
-masix plugin install-file \
-  --file packages/plugin-base/discovery/0.2.4/discovery-macos-aarch64.pkg \
-  --plugin discovery \
-  --version 0.2.4 \
-  --package-type mcp_binary
+masix plugin install-base
 ```
 
+`0.3.0` currently uses bundled source-build fallback on macOS until the Apple prebuilt artifact is refreshed.
+
 After install, run:
 
 ```bash
 masix plugin enable discovery
 masix restart
 ```
+
+Available commands in `0.3.0`:
+
+- `web-search`
+- `tor-search`
+- `web-fetch`
+- `torrent-search`
+- `torrent-extract`
+- `search-status`

package/packages/plugin-base/discovery/source/Cargo.toml

@@ -1,13 +1,14 @@
 [package]
 name = "masix-plugin-discovery"
-version = "0.2.4"
+version = "0.3.0"
 edition.workspace = true
 license.workspace = true
 
 [dependencies]
 anyhow.workspace = true
 clap.workspace = true
-reqwest.workspace = true
+dirs.workspace = true
+reqwest = { workspace = true, features = ["socks"] }
 scraper.workspace = true
 serde.workspace = true
 serde_json.workspace = true

package/packages/plugin-base/discovery/source/plugin.manifest.json

@@ -1,7 +1,7 @@
 {
   "id": "discovery",
   "name": "MasiX Discovery Tools",
-  "version": "0.2.4",
+  "version": "0.3.0",
   "visibility": "plugin-base",
   "package_type": "mcp_binary",
   "entrypoint": "masix-plugin-discovery",
@@ -12,19 +12,24 @@
   ],
   "platforms_tested": [
     "linux-x86_64",
-    "android-aarch64-termux",
-    "macos-aarch64"
+    "android-aarch64-termux"
   ],
   "platforms_planned": [],
   "commands": [
     "web-search",
+    "tor-search",
     "web-fetch",
     "torrent-search",
     "torrent-extract",
+    "search-status",
+    "manifest",
     "serve-mcp"
   ],
   "tool_access": {
     "default_required_role": "user",
-    "per_tool_required_role": {}
+    "per_tool_required_role": {
+      "tor_search": "user",
+      "search_status": "user"
+    }
   }
 }

package/packages/plugin-base/discovery/source/src/doh.rs

@@ -0,0 +1,103 @@
+use anyhow::{anyhow, Result};
+use reqwest::Client;
+use serde::Deserialize;
+use std::net::IpAddr;
+use std::time::Duration;
+
+const DOH_TIMEOUT_SECS: u64 = 5;
+const CLOUDFLARE_DOH: &str = "https://cloudflare-dns.com/dns-query";
+const GOOGLE_DOH: &str = "https://dns.google/dns-query";
+const DNS_TYPE_A: &str = "A";
+const DNS_TYPE_AAAA: &str = "AAAA";
+
+#[derive(Debug, Clone)]
+pub struct DohResolver {
+    client: Client,
+}
+
+#[derive(Debug, Deserialize)]
+struct DohResponse {
+    #[serde(default, rename = "Answer")]
+    answer: Vec<DohAnswer>,
+}
+
+#[derive(Debug, Deserialize)]
+struct DohAnswer {
+    #[serde(default)]
+    data: String,
+    #[serde(default, rename = "type")]
+    record_type: u32,
+}
+
+impl DohResolver {
+    pub fn new(user_agent: &str) -> Result<Self> {
+        let client = Client::builder()
+            .user_agent(user_agent)
+            .timeout(Duration::from_secs(DOH_TIMEOUT_SECS))
+            .build()?;
+        Ok(Self { client })
+    }
+
+    pub async fn resolve(&self, hostname: &str) -> Result<Vec<IpAddr>> {
+        // Try IPv4 via Cloudflare first (most common case)
+        if let Ok(r) = self.resolve_via(CLOUDFLARE_DOH, hostname, DNS_TYPE_A).await {
+            if !r.is_empty() {
+                return Ok(r);
+            }
+        }
+        // Try IPv6 via Cloudflare
+        if let Ok(r) = self.resolve_via(CLOUDFLARE_DOH, hostname, DNS_TYPE_AAAA).await {
+            if !r.is_empty() {
+                return Ok(r);
+            }
+        }
+        // IPv4 via Google fallback
+        if let Ok(r) = self.resolve_via(GOOGLE_DOH, hostname, DNS_TYPE_A).await {
+            if !r.is_empty() {
+                return Ok(r);
+            }
+        }
+        // IPv6 via Google fallback
+        self.resolve_via(GOOGLE_DOH, hostname, DNS_TYPE_AAAA).await
+    }
+
+    pub async fn resolve_with_fallback(&self, hostname: &str) -> String {
+        self.resolve(hostname)
+            .await
+            .ok()
+            .and_then(|items| items.into_iter().next())
+            .map(|ip| ip.to_string())
+            .unwrap_or_else(|| hostname.to_string())
+    }
+
+    async fn resolve_via(&self, endpoint: &str, hostname: &str, dns_type: &str) -> Result<Vec<IpAddr>> {
+        let response = self
+            .client
+            .get(endpoint)
+            .query(&[("name", hostname), ("type", dns_type)])
+            .header("Accept", "application/dns-json")
+            .send()
+            .await?;
+
+        if !response.status().is_success() {
+            return Err(anyhow!(
+                "DoH resolver {} returned HTTP {}",
+                endpoint,
+                response.status()
+            ));
+        }
+
+        let payload: DohResponse = response.json().await?;
+        let mut output = Vec::new();
+        for answer in payload.answer {
+            // Accept A (1) and AAAA (28) records
+            if answer.record_type != 1 && answer.record_type != 28 {
+                continue;
+            }
+            if let Ok(ip) = answer.data.parse::<IpAddr>() {
+                output.push(ip);
+            }
+        }
+        Ok(output)
+    }
+}

package/packages/plugin-base/discovery/source/src/magnet_cache.rs

@@ -0,0 +1,113 @@
+use anyhow::Result;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::path::{Path, PathBuf};
+use std::time::{SystemTime, UNIX_EPOCH};
+use tokio::sync::Mutex;
+
+const CACHE_TTL_SECS: u64 = 72 * 60 * 60;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct CacheEntry {
+    magnet: String,
+    expires_at: u64,
+}
+
+#[derive(Debug)]
+pub struct MagnetCache {
+    path: PathBuf,
+    entries: Mutex<HashMap<String, CacheEntry>>,
+}
+
+impl MagnetCache {
+    pub async fn new(data_dir: Option<&Path>) -> Result<Self> {
+        let root = resolve_cache_root(data_dir);
+        std::fs::create_dir_all(&root)?;
+        let path = root.join("magnet_cache.json");
+        let entries = if path.is_file() {
+            let content = std::fs::read_to_string(&path).unwrap_or_default();
+            serde_json::from_str(&content).unwrap_or_default()
+        } else {
+            HashMap::new()
+        };
+        let cache = Self {
+            path,
+            entries: Mutex::new(entries),
+        };
+        cache.cleanup_expired().await?;
+        Ok(cache)
+    }
+
+    pub async fn get(&self, url: &str) -> Option<String> {
+        let mut entries = self.entries.lock().await;
+        let now = now_unix_secs();
+        let value = entries.get(url).cloned();
+        match value {
+            Some(entry) if entry.expires_at > now => Some(entry.magnet),
+            Some(_) => {
+                entries.remove(url);
+                let _ = self.flush_locked(&entries);
+                None
+            }
+            None => None,
+        }
+    }
+
+    pub async fn set(&self, url: &str, magnet: &str) -> Result<()> {
+        let mut entries = self.entries.lock().await;
+        entries.insert(
+            url.to_string(),
+            CacheEntry {
+                magnet: magnet.to_string(),
+                expires_at: now_unix_secs().saturating_add(CACHE_TTL_SECS),
+            },
+        );
+        self.flush_locked(&entries)
+    }
+
+    pub async fn size(&self) -> usize {
+        self.entries.lock().await.len()
+    }
+
+    pub const fn ttl_hours() -> u64 {
+        72
+    }
+
+    async fn cleanup_expired(&self) -> Result<()> {
+        let mut entries = self.entries.lock().await;
+        let now = now_unix_secs();
+        entries.retain(|_, entry| entry.expires_at > now);
+        self.flush_locked(&entries)
+    }
+
+    fn flush_locked(&self, entries: &HashMap<String, CacheEntry>) -> Result<()> {
+        let content = serde_json::to_string_pretty(entries)?;
+        let tmp = self.path.with_extension("json.tmp");
+        std::fs::write(&tmp, &content)?;
+        std::fs::rename(&tmp, &self.path)?;
+        Ok(())
+    }
+}
+
+fn resolve_cache_root(data_dir: Option<&Path>) -> PathBuf {
+    if let Ok(value) = std::env::var("MASIX_DATA_DIR") {
+        let trimmed = value.trim();
+        if !trimmed.is_empty() {
+            return PathBuf::from(trimmed).join("discovery");
+        }
+    }
+    if let Some(path) = data_dir {
+        return path.join("discovery");
+    }
+    dirs::home_dir()
+        .unwrap_or_else(|| PathBuf::from("."))
+        .join(".masix")
+        .join("discovery")
+}
+
+fn now_unix_secs() -> u64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|duration| duration.as_secs())
+        .unwrap_or(0)
+}