#!/bin/bash
if [ ! -x /usr/bin/ruby ]; then
  printf '此电脑缺少修复工具需要的系统运行组件，请联系支持。\n'
  read -r repair_close
  exit 1
fi
/usr/bin/ruby --disable-gems - <<'CS_NETWORK_RUBY'
# Built-in macOS Ruby host adapter; guest recovery stays the reviewed Python owner.
require 'json'
require 'open3'
require 'socket'
require 'timeout'
require 'shellwords'
require 'tempfile'
require 'fileutils'
require 'ipaddr'
require 'base64'
module CodeSandboxNetworkCustomer
  class Error < StandardError; end
  ROOT = File.expand_path('~/Library/Application Support/code-sandbox')
  MESSAGES = {'healthy'=>'沙箱联网正常','recovered'=>'沙箱联网已恢复','cooldown'=>'已尝试修复，稍后再运行一次',
    'upstream_unavailable'=>'联网复测仍未通过，请联系支持检查网络线路','blocked'=>'修复条件未通过，请将检查结果发给支持人员'}
  def self.execute(argv, input='', seconds=12)
    out=err=nil; status=nil
    Open3.popen3(*argv, :pgroup=>true) do |stdin,stdout,stderr,wait|
      reader=Thread.new { begin; stdout.read; rescue IOError; ''; end }; errors=Thread.new { begin; stderr.read; rescue IOError; ''; end }
      begin
        Timeout.timeout(seconds) do
          stdin.write(input); stdin.close
          status=wait.value; out=reader.value; err=errors.value
        end
      rescue Timeout::Error
        Process.kill('TERM',-wait.pid) rescue nil
        raise Error,'检查超时，请稍后重试'
      ensure
        stdin.close rescue nil; stdout.close rescue nil; stderr.close rescue nil
      end
    end
    [status.exitstatus,out,err]
  end
  def self.atomic(path, bytes, expected=nil, mode=0600)
    raise Error,'配置文件位置已变化，请联系支持检查' if File.symlink?(path)
    FileUtils.mkdir_p(File.dirname(path),:mode=>0700)
    Tempfile.create(['.network-repair-',''],File.dirname(path)) do |f|
      f.binmode; f.write(bytes); f.flush; f.fsync; f.chmod(mode)
      raise Error,'配置正在变化，请稍后重试' if expected && File.binread(path)!=expected
      File.rename(f.path,path)
    end
  end
  def self.outbound(cfg)
    rows=cfg.fetch('outbounds',[]).select { |x| x['tag']=='proxy-out' }
    raise Error,'此网络配置需要由应用恢复，请将检查结果发给支持人员' unless rows.size==1 && rows[0]['type']=='socks'
    rows[0]
  end
  def self.aligned(cfg,credential,server,port)
    row=outbound(cfg)
    raise Error,'沙箱连接地址已变化，请联系支持检查' unless row['server']==server && row['server_port']==port
    copy=JSON.parse(JSON.generate(cfg)); outbound(copy).merge!(credential); copy
  end
  def self.authenticate(port,credential)
    u=credential.fetch('username').b; p=credential.fetch('password').b
    raise Error,'本机连接配置无效，请联系支持检查' unless u.bytesize.between?(1,255) && p.bytesize.between?(1,255)
    Timeout.timeout(4) do
      Socket.tcp('127.0.0.1',port,:connect_timeout=>3) do |socket|
        socket.write([5,1,2].pack('C*'))
        raise Error,'本机网络隔离组件尚未就绪，请先打开应用' unless socket.read(2)==[5,2].pack('C*')
        socket.write([1,u.bytesize].pack('C*')+u+[p.bytesize].pack('C')+p)
        raise Error,'本机拒绝当前连接配置，请联系支持检查' unless socket.read(2)==[1,0].pack('C*')
      end
    end
  rescue Timeout::Error, SystemCallError, IOError
    raise Error,'本机网络隔离组件尚未就绪，请先打开应用'
  end
  def self.repair(id,guest_code,root=ROOT)
    raise Error,'目标沙箱名称无效' unless id.match?(/\Asbx-[a-zA-Z0-9_-]+\z/)
    version=execute(['/usr/libexec/PlistBuddy','-c','Print :CFBundleShortVersionString','/Applications/Code Sandbox.app/Contents/Info.plist'])[1].strip
    return {'status'=>'new_app','message'=>'此版本请使用应用自身的网络恢复；请将检查结果发给支持人员'} unless version=='0.4.14'
    name='code-sandbox-'+id
    code,text=execute([File.join(root,'runtime/lima/bin/limactl'),'list','--format','{{.Name}} {{.Status}}'])
    raise Error,'沙箱状态读取失败，请先打开应用' unless code==0
    return {'status'=>'stopped','message'=>'请先从应用启动要修复的沙箱，再运行此文件'} unless text.lines.map(&:split).include?([name,'Running'])
    base=File.join(root,'browsers',id)
    credential=JSON.parse(File.binread(File.join(base,'host-proxy-socks-credential.json')))
    raise Error,'本机连接配置无效，请联系支持检查' unless credential.keys.sort==['password','username'] && credential.values.all? { |x| x.is_a?(String) && !x.empty? }
    host_path=File.join(base,'host-singbox.json'); host_raw=File.binread(host_path); host=JSON.parse(host_raw)
    inbound=host.fetch('inbounds',[]).select { |x| x['tag']=='vm-socks-in' }
    raise Error,'本机连接配置正在变化，请稍后重试' unless inbound.size==1 && inbound[0].fetch('users',[]).include?(credential)
    port=inbound[0]['listen_port']; raise Error,'本机连接地址无效，请联系支持检查' unless port.is_a?(Integer) && port.between?(1,65535)
    authenticate(port,credential)
    path=File.join(root,'runtimes',id,'sing-box.json'); original=File.binread(path); cfg=JSON.parse(original); server=outbound(cfg)['server']
    begin
      ip=IPAddr.new(server)
      private_ip=ip.ipv4? && ['10.0.0.0/8','172.16.0.0/12','192.168.0.0/16'].any? { |n| IPAddr.new(n).include?(ip) }
    rescue IPAddr::InvalidAddressError, TypeError
      private_ip=false
    end
    raise Error,'此沙箱的本机连接地址需要由支持人员检查' unless private_ip
    updated=aligned(cfg,credential,server,port)
    if updated!=cfg
      raise Error,'配置正在变化，请稍后重试' unless File.binread(host_path)==host_raw && JSON.parse(File.binread(File.join(base,'host-proxy-socks-credential.json')))==credential
      backup=File.join(root,'support-backups','network-customer'); FileUtils.mkdir_p(backup,:mode=>0700)
      saved=File.join(backup,'sing-box-'+Process.pid.to_s+'-'+(Time.now.to_r*1_000_000_000).to_i.to_s+'.json')
      File.open(saved,File::WRONLY|File::CREAT|File::EXCL,0600) { |f| f.write(original); f.flush; f.fsync }
      atomic(path,JSON.pretty_generate(updated)+"\n",original)
    end
    raise Error,'配置正在变化，请稍后重试' unless File.binread(host_path)==host_raw && JSON.parse(File.binread(File.join(base,'host-proxy-socks-credential.json')))==credential
    ssh=File.expand_path('~/.lima/'+name+'/ssh.config'); raise Error,'沙箱连接尚未就绪，请先打开应用' unless File.file?(ssh)
    body="exec(__import__('base64').b64decode('#{Base64.strict_encode64(guest_code)}'))"
    command='sudo -n python3 -c '+Shellwords.escape(body)
    payload=credential.merge('server'=>server,'port'=>port,'repair'=>true,'dropin'=>"[Unit]\nAfter=systemd-networkd.service\nPartOf=systemd-networkd.service\n")
    code,out=execute(['/usr/bin/ssh','-T','-F',ssh,'-o','BatchMode=yes','-o','ConnectTimeout=5','lima-'+name,command],JSON.generate(payload),48)
    result=JSON.parse(out); raise Error,'网络修复未完成，请将检查结果发给支持人员' unless result.is_a?(Hash) && result['status']
    result['source_changed']=updated!=cfg; result
  end
  def self.main(guest_code)
    root=ROOT; dir=File.join(root,'support','customer-network'); FileUtils.mkdir_p(dir,:mode=>0700); File.chmod(0700,dir)
    result=nil
    File.open(File.join(dir,'repair.lock'),'a',0600) do |lock|
      raise Error,'已有网络检查正在执行，请等该窗口结束' unless lock.flock(File::LOCK_EX|File::LOCK_NB)
      code,text=execute([File.join(root,'runtime/lima/bin/limactl'),'list','--format','{{.Name}} {{.Status}}'])
      raise Error,'沙箱状态读取失败，请先打开应用' unless code==0
      names=text.lines.map(&:split).select { |r| r.size==2 && r[1]=='Running' && r[0].start_with?('code-sandbox-sbx-') }.map { |r| r[0].sub('code-sandbox-','') }
      raise Error,'请先从应用启动要修复的沙箱，再运行此文件' if names.empty?
      id=names[0]
      if names.size>1
        names.each_with_index { |n,i| puts "#{i+1}. #{n}" }; print '请选择要修复的沙箱编号：'
        answer=STDIN.gets.to_s.strip; raise Error,'未选择沙箱' unless answer.match?(/\A[0-9]+\z/) && answer.to_i.between?(1,names.size)
        id=names[answer.to_i-1]
      end
      puts '正在检查沙箱网络，必要时修复网络隔离组件。已有网络请求可能短暂中断。'
      result=repair(id,guest_code)
      atomic(File.join(dir,'修复结果.json'),JSON.pretty_generate(result)+"\n")
    end
    puts result['message'] || MESSAGES[result['status']] || '修复未完成，请将检查结果发给支持人员'
    puts '检查记录：'+File.join(dir,'修复结果.json')
    ['healthy','recovered'].include?(result['status']) ? 0 : 1
  rescue Error => e
    warn e.message
    atomic(File.join(dir,'修复结果.json'),JSON.pretty_generate({'status'=>'blocked','message'=>e.message})+"\n") rescue nil
    warn '检查记录：'+File.join(dir,'修复结果.json') if dir
    1
  rescue StandardError
    message='网络检查未完成，请先打开应用；若仍失败，请联系支持。'; warn message
    atomic(File.join(dir,'修复结果.json'),JSON.pretty_generate({'status'=>'blocked','message'=>message})+"\n") rescue nil
    warn '检查记录：'+File.join(dir,'修复结果.json') if dir
    1
  end
end

begin; STDIN.reopen('/dev/tty'); rescue SystemCallError; end
code=CodeSandboxNetworkCustomer.main(Base64.strict_decode64('
import json, os, pathlib, re, shutil, subprocess, tempfile, time, sys
class GuardError(Exception): pass
def run(args, timeout=10):
    p=subprocess.run(args,stdout=subprocess.PIPE,stderr=subprocess.PIPE,timeout=timeout)
    return p.returncode,p.stdout.decode(errors="replace")
def load(path): return json.loads(pathlib.Path(path).read_text())
def outbound(g):
    a=[x for x in g.get("outbounds",[]) if x.get("tag")=="proxy-out"]
    if len(a)!=1 or a[0].get("type")!="socks": raise GuardError("网络配置不适用本次修复")
    return a[0]
def endpoint(g,p):
    o=outbound(g)
    if o.get("server")!=p["server"] or o.get("server_port")!=p["port"]:
        raise GuardError("网络地址已变化，修复已暂停")
    return o
def write(path,data,backup=True,mode=0o600):
    path=pathlib.Path(path)
    if path.is_symlink(): raise GuardError("配置文件位置已变化，修复已暂停")
    old=path.read_bytes() if path.exists() else None
    if old==data: return False
    root=pathlib.Path("/var/backups/code-sandbox-network-support")
    root.mkdir(mode=0o700,parents=True,exist_ok=True)
    if backup and old is not None:
        fd,b=tempfile.mkstemp(prefix=path.name+"-",dir=str(root))
        with os.fdopen(fd,"wb") as f: f.write(old)
        os.chmod(b,0o600)
    path.parent.mkdir(mode=0o755,parents=True,exist_ok=True)
    fd,t=tempfile.mkstemp(prefix=".network-repair-",dir=str(path.parent))
    try:
        with os.fdopen(fd,"wb") as f: f.write(data); f.flush(); os.fsync(f.fileno())
        os.chmod(t,mode)
        if (path.read_bytes() if path.exists() else None)!=old:
            raise GuardError("配置正在变化，稍后重试")
        os.replace(t,path)
    finally:
        if os.path.exists(t): os.unlink(t)
    return True
def firewall_ready(text,p):
    narrow=any("meta skuid 9000" in line and
        ("ip daddr "+p["server"]+" ") in line and
        ("tcp dport "+str(p["port"])+" ") in line and
        " accept" in line and 'comment "host-proxy-only"' in line for line in text.splitlines())
    return "policy drop;" in text and narrow and '"managed-tunnel"' in text

def configured_tunnel(config):
    interfaces=[x.get("interface_name") for x in config.get("inbounds",[]) if x.get("type")=="tun"]
    if len(interfaces)!=1 or not isinstance(interfaces[0],str) or not re.fullmatch(r"cs-tun0|cs-tun-[0-9a-f]{8}",interfaces[0]):
        raise GuardError("沙箱网络接口尚未确认，修复已暂停")
    return interfaces[0]

def route_matches(route,tunnel):
    return bool(re.search(r"\bdev "+re.escape(tunnel)+r"(?:\s|$)",route))

def reconcile(p):
    if os.geteuid()!=0: raise GuardError("缺少沙箱内修复权限")
    for k in ("username","password"):
        if not isinstance(p.get(k),str) or not p[k]: raise GuardError("连接配置无效")
    source=load("/opt/code-sandbox/sing-box.json")
    src=endpoint(source,p)
    if any(src.get(k)!=p[k] for k in ("username","password")):
        raise GuardError("沙箱启动配置尚未同步，稍后重试")
    code,fw=run(["nft","-n","-s","list","table","inet","code_sandbox"])
    if code or not firewall_ready(fw,p): raise GuardError("网络隔离规则与当前连接不匹配，修复已暂停")
    config=load("/etc/sing-box/config.json"); out=endpoint(config,p)
    tunnel=configured_tunnel(config)
    if configured_tunnel(source)!=tunnel or not any('oifname "'+tunnel+'"' in line and " accept" in line and 'comment "managed-tunnel"' in line for line in fw.splitlines()):
        raise GuardError("沙箱网络接口与隔离规则不一致，修复已暂停")
    changed=any(out.get(k)!=p[k] for k in ("username","password"))
    try:
        live=endpoint(load("/run/code-sandbox/sing-box.json"),p)
        live_match=all(live.get(k)==p[k] for k in ("username","password"))
    except (FileNotFoundError,ValueError): live_match=False
    code,uid=run(["id","-u","workspace"])
    if code or not uid.strip().isdigit(): raise GuardError("沙箱终端账号不可用")
    route_cmd=["ip","-4","route","get","1.1.1.1","uid",uid.strip()]
    code,route=run(route_cmd); route_ok=code==0 and route_matches(route,tunnel)
    active=run(["systemctl","is-active","--quiet","code-sandbox-singbox.service"])[0]==0
    needed=changed or not live_match or not route_ok or not active
    result={"status":"healthy","restarted":False,"credential_changed":changed,"route_ready":route_ok}
    if needed and not p["repair"]:
        result["status"]="needs_repair"; return result
    state_path=pathlib.Path("/var/lib/code-sandbox-network-support/state.json")
    state=load(state_path) if state_path.exists() else {}
    if needed and time.time()-state.get("last_restart",0)<300:
        result["status"]="cooldown"; return result
    if p["repair"]:
        drop=pathlib.Path("/etc/systemd/system/code-sandbox-singbox.service.d/90-support-networkd.conf")
        desired=p["dropin"].encode()
        if drop.exists() and drop.read_bytes()!=desired:
            raise GuardError("已有网络恢复设置不同，修复已暂停")
        if not drop.exists() and write(drop,desired,mode=0o644):
            if run(["systemctl","daemon-reload"])[0]: raise GuardError("网络恢复设置未能生效")
    if needed:
        if changed:
            out.update({k:p[k] for k in ("username","password")})
            write("/etc/sing-box/config.json",(json.dumps(config,indent=2)+"\n").encode())
        write(state_path,(json.dumps({"last_restart":time.time()})+"\n").encode(),backup=False)
        if run(["systemctl","restart","code-sandbox-singbox.service"],20)[0]:
            raise GuardError("网络隔离组件未能重新启动")
        result["restarted"]=True
        end=time.monotonic()+5
        while time.monotonic()<end:
            code,route=run(route_cmd)
            if code==0 and route_matches(route,tunnel): break
            time.sleep(.25)
        result["route_ready"]=code==0 and route_matches(route,tunnel)
        if not result["route_ready"]: raise GuardError("沙箱网络路由尚未恢复")
        run(["resolvectl","flush-caches"])
    passed=False
    for url in ("https://www.apple.com","https://api.anthropic.com"):
        code,http=run(["runuser","-u","workspace","--","curl","--disable","--noproxy","*","-I","-sS",
          "--connect-timeout","4","--max-time","6","-o","/dev/null","-w","%{http_code}",url],8)
        if code==0 and re.fullmatch(r"[1-5][0-9]{2}",http): passed=True; break
    result["https_ready"]=passed
    result["status"]="recovered" if passed and needed else "healthy" if passed else "upstream_unavailable"
    return result
if __name__=="__main__":
    try:
        p=json.load(sys.stdin)
        print(json.dumps(reconcile(p),ensure_ascii=False))
    except GuardError as e:
        print(json.dumps({"status":"blocked","message":str(e)},ensure_ascii=False)); sys.exit(1)
    except Exception:
        print(json.dumps({"status":"blocked","message":"网络检查未完成，稍后重试"},ensure_ascii=False)); sys.exit(1)
'))
puts; puts '按回车关闭。'; STDIN.gets if STDIN.tty?
exit code

CS_NETWORK_RUBY