pindo 5.2.4 → 5.3.7

data/lib/pindo/client/pgyer_feishu_oauth_cli.rb

@@ -20,14 +20,15 @@ module Pindo
     def initialize(client_id)
       @client_id = client_id
       @feishu_auth_url = 'https://passport.feishu.cn/suite/passport/oauth/authorize?'
-      
+
       # 保持原有的redirect_uri，飞书OAuth流程中仍使用这个URL
       # 前端UI会检测state=terminal_login并自动跳转到localhost:8899
       @redirect_uri = 'https://pgyerapps.com/login'
       @pgyer_api_endpoint = 'https://api.pgyerapps.com/api/user/lark_qr_login'
-      
+
       @state = 'terminal_login'
-      
+      @server_port = 8899
+
       @larkScopeList = [
         'task:task:write',
         'task:section:write',
@@ -44,53 +45,120 @@ module Pindo
     def authorize
       # 不再检查已存储的令牌，直接开始授权流程
       authorization_uri = build_authorization_uri
-      puts "正在打开浏览器进行飞书OAuth授权..."
-      puts "授权URI: #{authorization_uri}"
-      puts "注意：授权成功后，网页将自动跳转至本地http://localhost:8899"
-      
+      puts "🚀 正在打开浏览器进行飞书 OAuth 授权..."
+      puts "\n📋 授权链接（如浏览器未自动打开，请手动复制访问）:"
+      puts "-" * 60
+      puts authorization_uri
+      puts "-" * 60
+
       # 在浏览器中打开授权URL
       open_browser(authorization_uri)
-      
+
       # 启动本地服务器处理回调
       code = start_callback_server
-      
+
       # 如果自动获取失败，提示用户手动输入
       if code.nil?
-        puts "自动获取授权码失败，您可以手动输入："
-        puts "1. 授权码 (直接复制'code='后面的内容)"
-        puts "2. 完整回调URL (例如: http://localhost:8899/?code=xxxx...)"
-        print "> "
-        input = STDIN.gets.chomp
-        
-        if input.start_with?("http")
-          # 尝试从URL中提取code
+        # 停止任何可能的 spinner 动画
+        if defined?(Funlog) && Funlog.instance.instance_variable_get(:@spinner_log)
+          Funlog.instance.instance_variable_set(:@spinner_log, nil)
+        end
+
+        loop do
+          puts "\n⚠️  自动获取授权码失败，请选择操作："
+          puts "  1. 输入授权码（复制 code= 后的内容）"
+          puts "  2. 输入完整回调 URL"
+          puts "  3. 重新打开授权网页"
+          puts "  4. 退出登录"
+          print "请选择 (1-4): "
+          STDOUT.flush  # 确保提示符立即显示
+
           begin
-            uri = URI(input)
-            query_params = URI.decode_www_form(uri.query || '').to_h
-            code = query_params['code']
-            if code
-              puts "从URL中成功提取授权码"
+            choice = STDIN.gets&.chomp
+
+            # 处理 Ctrl+C 中断
+            if choice.nil?
+              puts "\n\n🚪 用户中断操作"
+              return :user_cancelled
             end
-          rescue => e
-            puts "无法从URL中提取授权码: #{e.message}"
+
+            case choice
+            when "1"
+              puts "\n请输入授权码:"
+              print "🔑 "
+              STDOUT.flush  # 确保提示符立即显示
+              code_input = STDIN.gets&.chomp
+              if code_input.nil?
+                puts "\n🚪 用户中断操作"
+                return :user_cancelled
+              elsif !code_input.empty?
+                code = code_input
+                break
+              else
+                puts "⚠️  授权码不能为空，请重新选择"
+              end
+            when "2"
+              puts "\n请输入完整回调 URL:"
+              print "🔗 "
+              STDOUT.flush  # 确保提示符立即显示
+              url_input = STDIN.gets&.chomp
+              if url_input.nil?
+                puts "\n🚪 用户中断操作"
+                return :user_cancelled
+              elsif url_input.start_with?("http")
+                # 尝试从 URL 中提取 code
+                begin
+                  uri = URI(url_input)
+                  query_params = URI.decode_www_form(uri.query || '').to_h
+                  code = query_params['code']
+                  if code
+                    puts "✅ 成功从 URL 提取授权码"
+                    break
+                  else
+                    puts "❌ URL 中未找到授权码，请重新选择"
+                  end
+                rescue => e
+                  puts "❌ 解析 URL 失败: #{e.message}"
+                end
+              else
+                puts "❌ 无效的 URL 格式，请重新选择"
+              end
+            when "3"
+              # 重新打开授权网页
+              puts "\n🔄 重新打开授权网页..."
+              open_browser(authorization_uri)
+              # 重新启动服务器尝试获取授权码
+              code = start_callback_server
+              if code
+                break
+              end
+              # 如果还是失败，继续循环让用户选择
+            when "4"
+              puts "\n🚪 已取消登录"
+              return :user_cancelled
+            else
+              puts "❌ 无效的选择，请输入 1-4"
+            end
+          rescue Interrupt
+            puts "\n\n🚪 用户中断操作"
+            return :user_cancelled
           end
-        else
-          # 将输入直接作为code
-          code = input unless input.empty?
         end
       end
-      
+
       if code
-        puts "成功获取授权码！正在使用飞书身份登录Pgyer..."
-        puts "code: #{code}"
+        puts "\n✅ 成功获取授权码"
+        print "🔄 正在验证飞书身份..."
+        STDOUT.flush
         if login_pgyer_with_feishu(code:code)
-          puts "Pgyer登录成功！"
+          puts " ✅"
+          puts "🎉 登录成功！欢迎使用 Pgyer"
           # 登录成功后，返回true，外部程序可以通过访问access_token属性获取token
           return true
         end
         return false
       else
-        puts "授权失败"
+        puts "\n❌ 授权失败"
         return false
       end
     end
@@ -132,12 +200,9 @@ module Pindo
         scope: @larkScopeList.join(' ')
       }
       
-      puts "请求Pgyer API: #{@pgyer_api_endpoint}"
-      puts "请求参数: #{body_params.to_json}"
-      
       # 使用HttpClient发送请求
       con = HttpClient.create_instance_with_proxy
-      
+
       begin
         res = con.post do |req|
           req.url @pgyer_api_endpoint
@@ -145,8 +210,6 @@ module Pindo
           req.body = body_params.to_json
         end
         
-        puts "API响应状态码: #{res.status}"
-        
         # 处理响应
         result = nil
         if !res.body.nil?
@@ -162,26 +225,39 @@ module Pindo
               return true
             else
               error_msg = result['meta'] && result['meta']['message'] ? result['meta']['message'] : '未知错误'
-              puts "Pgyer登录失败: #{error_msg}"
+              puts " ❌"
+              puts "登录失败: #{error_msg}"
               return false
             end
           rescue => e
-            puts "解析响应失败: #{e.message}"
-            puts "原始响应: #{res.body[0..200]}"
+            puts " ❌"
+            puts "响应解析失败: #{e.message}"
             return false
           end
         else
-          puts "请求返回空响应"
+          puts " ❌"
+          puts "服务器返回空响应"
           return false
         end
       rescue => e
-        puts "请求过程中出错: #{e.class} - #{e.message}"
+        puts " ❌"
+        puts "网络请求失败: #{e.message}"
         return false
       end
     end
 
     private
 
+    # 获取跨平台的 null 设备路径
+    def get_null_device
+      case RbConfig::CONFIG['host_os']
+      when /mswin|mingw|cygwin/
+        'NUL'
+      else
+        '/dev/null'
+      end
+    end
+
 
     # 构建授权URI
     def build_authorization_uri
@@ -201,11 +277,13 @@ module Pindo
 
     # 在浏览器中打开URL
     def open_browser(url)
-      if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
-        system("start", url)
-      elsif RbConfig::CONFIG['host_os'] =~ /darwin/
+      case RbConfig::CONFIG['host_os']
+      when /mswin|mingw|cygwin/
+        # Windows: 使用双引号包围URL避免参数解析问题
+        system("start \"\" \"#{url}\"")
+      when /darwin/
         system("open", url)
-      elsif RbConfig::CONFIG['host_os'] =~ /linux|bsd/
+      when /linux|bsd/
         system("xdg-open", url)
       else
         puts "无法自动打开浏览器，请手动访问: #{url}"
@@ -215,15 +293,38 @@ module Pindo
     # 启动本地服务器处理回调
     def start_callback_server
       code = nil
-      
-      puts "启动本地服务器，监听端口8899..."
-      
-      # 使用本地8899端口处理回调，不管redirect_uri配置如何
-      server = WEBrick::HTTPServer.new(
-        Port: 8899,
-        Logger: WEBrick::Log.new("/dev/null"),
-        AccessLog: []
-      )
+
+      # 检查并处理端口占用
+      unless ensure_port_available(@server_port)
+        puts "✗ 无法使用端口 #{@server_port}，登录失败"
+        return nil
+      end
+
+      puts "\n🌐 本地服务器已启动（端口: #{@server_port}）"
+      puts "💡 提示: 按 Ctrl+C 可中断并选择其他操作"
+      puts "🔄 等待飞书授权回调..."
+
+      begin
+        # 使用本地8899端口处理回调，不管redirect_uri配置如何
+        server = WEBrick::HTTPServer.new(
+          Port: @server_port,
+          BindAddress: '127.0.0.1',
+          Logger: WEBrick::Log.new(get_null_device),
+          AccessLog: []
+        )
+      rescue Errno::EADDRINUSE
+        puts "✗ 端口 #{@server_port} 仍被占用，无法启动服务器"
+        return nil
+      rescue Errno::ENOENT
+        puts "✗ 启动服务器失败: 系统找不到指定的路径或文件"
+        return nil
+      rescue => e
+        puts "✗ 启动服务器失败: #{e.message}"
+        if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
+          puts "  提示: 如果是Windows系统，请确保防火墙允许Ruby访问网络"
+        end
+        return nil
+      end
 
       # 处理根路径的请求
       server.mount_proc '/' do |req, res|
@@ -234,9 +335,10 @@ module Pindo
           # 安全解析请求参数
           begin
             query_params = URI.decode_www_form(req.query_string || '').to_h
-            puts "解析的参数: #{query_params.inspect}"
+            # 只在有code时输出日志，避免多余信息
+            # puts "解析的参数: #{query_params.inspect}" if query_params['code']
           rescue => e
-            puts "解析请求参数失败: #{e.message}"
+            # puts "解析请求参数失败: #{e.message}"
             query_params = {}
           end
           
@@ -246,12 +348,13 @@ module Pindo
           #   res.body = "状态不匹配，可能存在CSRF攻击风险"
           # elsif query_params['error']
           if query_params['error']
-            puts "授权错误: #{query_params['error']}"
+            # puts "授权错误: #{query_params['error']}"
             res.content_type = "text/html; charset=UTF-8"
             res.body = "授权错误: #{query_params['error']}"
           elsif query_params['code']
             code = query_params['code']
-            puts "成功获取授权码: #{code}"
+            # 成功获取时不输出，避免重复
+            # puts "成功获取授权码: #{code}"
             res.content_type = "text/html; charset=UTF-8"
             res.body = <<-HTML
             <!DOCTYPE html>
@@ -349,30 +452,26 @@ module Pindo
             </html>
             HTML
           else
-            puts "未获取到授权码"
+            # 忽略没有参数的请求（如favicon.ico等）
+            # puts "未获取到授权码"
             res.content_type = "text/html; charset=UTF-8"
-            res.body = "未获取到授权码"
+            res.body = "等待授权中..."
           end
 
-          # 给用户更多时间看到页面内容，并让JavaScript倒计时完成
-          puts "4秒后关闭服务器..."
-          Thread.new do
-            sleep 4  # 设置为4秒，比JavaScript的3秒稍长一点，确保客户端有足够时间执行
-            server.shutdown
+          # 只在获取到code时关闭服务器
+          if code
+            Thread.new do
+              sleep 4  # 给用户时间看到成功页面
+              server.shutdown
+            end
           end
         rescue => e
-          puts "处理请求时出错: #{e.class} - #{e.message}"
-          puts e.backtrace.join("\n")
-          
+          # 静默处理错误，避免干扰用户
+          # puts "处理请求时出错: #{e.class} - #{e.message}"
+
           # 确保即使出错也返回有效的响应
           res.content_type = "text/html; charset=UTF-8"
           res.body = "处理请求时出错"
-          
-          # 出错时也关闭服务器
-          Thread.new do
-            sleep 4  # 与正常情况保持一致
-            server.shutdown
-          end
         end
       end
       
@@ -391,15 +490,179 @@ module Pindo
         server.shutdown
       end
 
-      if code
-        puts "成功获取授权码: #{code}"
+      # 返回获取到的code（如果有的话）
+      code
+    end
+
+    # 确保端口可用，处理端口占用问题
+    def ensure_port_available(port)
+      return true unless port_occupied?(port)
+
+      puts "⚠️  端口 #{port} 被占用，正在检查占用进程..."
+
+      # 获取占用端口的进程信息
+      process_info = get_port_process_info(port)
+
+      if process_info.nil?
+        puts "✗ 无法获取端口占用信息"
+        return false
+      end
+
+      puts "占用进程信息："
+      puts "  PID: #{process_info[:pid]}"
+      puts "  进程名: #{process_info[:name]}"
+      puts "  命令: #{process_info[:command]}"
+
+      # 检查是否是自己的进程（可能是之前未正常关闭的实例）
+      if process_info[:name].include?('ruby') && (process_info[:command].include?('pindo') || process_info[:command].include?('pgyer'))
+        puts "检测到可能是 Pindo/Pgyer 之前的遗留进程"
+        if ask_user_kill_process?
+          return kill_process_by_pid(process_info[:pid])
+        end
       else
-        puts "未获取到授权码"
+        puts "端口被其他应用程序占用"
+        if ask_user_kill_process?
+          return kill_process_by_pid(process_info[:pid])
+        end
       end
 
-      code
+      return false
+    end
+
+    # 检查端口是否被占用
+    def port_occupied?(port)
+      require 'socket'
+
+      begin
+        server = TCPServer.new('127.0.0.1', port)
+        server.close
+        false  # 端口未被占用
+      rescue Errno::EADDRINUSE
+        true   # 端口被占用
+      rescue => e
+        puts "⚠️  检查端口时出错: #{e.message}"
+        true   # 出错时假设端口被占用，避免冲突
+      end
     end
 
+    # 获取占用指定端口的进程信息
+    def get_port_process_info(port)
+      begin
+        # macOS/Linux 使用 lsof 命令
+        if system('which lsof > /dev/null 2>&1')
+          output = `lsof -ti :#{port} 2>/dev/null`.strip
+          return nil if output.empty?
+
+          pid = output.split("\n").first
+          return nil if pid.nil? || pid.empty?
+
+          # 获取进程详细信息
+          ps_output = `ps -p #{pid} -o pid,comm,args 2>/dev/null`.lines
+          return nil if ps_output.length < 2
+
+          process_line = ps_output[1].strip
+          parts = process_line.split(/\s+/, 3)
+
+          return {
+            pid: parts[0],
+            name: parts[1] || 'unknown',
+            command: parts[2] || 'unknown'
+          }
+        end
+
+        # Windows 使用 netstat 命令
+        if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
+          output = `netstat -ano | findstr :#{port}`.strip
+          return nil if output.empty?
+
+          lines = output.split("\n")
+          listening_line = lines.find { |line| line.include?('LISTENING') }
+          return nil unless listening_line
+
+          pid = listening_line.split.last
+          return nil if pid.nil? || pid.empty?
+
+          # 获取进程名称
+          task_output = `tasklist /FI "PID eq #{pid}" /FO CSV /NH 2>nul`.strip
+          if !task_output.empty?
+            process_name = task_output.split(',').first.gsub('"', '')
+            return {
+              pid: pid,
+              name: process_name,
+              command: process_name
+            }
+          end
+        end
+
+        return nil
+      rescue => e
+        puts "获取进程信息时出错: #{e.message}"
+        return nil
+      end
+    end
+
+    # 询问用户是否终止占用端口的进程
+    def ask_user_kill_process?
+      puts "\n是否终止占用端口的进程？"
+      puts "  y/yes - 终止进程并继续 (可能影响其他应用)"
+      puts "  n/no  - 取消登录 (默认)"
+      print "> "
+
+      begin
+        response = STDIN.gets&.chomp&.downcase
+        return ['y', 'yes'].include?(response)
+      rescue Interrupt
+        puts "\n\n用户中断操作"
+        return false
+      rescue => e
+        puts "无法读取用户输入: #{e.message}"
+        return false
+      end
+    end
+
+    # 根据 PID 终止进程
+    def kill_process_by_pid(pid)
+      return false if pid.nil? || pid.empty?
+
+      begin
+        puts "正在终止进程 #{pid}..."
+
+        # 跨平台的进程终止命令
+        if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
+          # Windows
+          success = system("taskkill /PID #{pid} /F >nul 2>&1")
+        else
+          # macOS/Linux - 先尝试优雅终止，再强制终止
+          success = system("kill -TERM #{pid} 2>/dev/null")
+          sleep(2)
+          # 检查进程是否还存在
+          if system("kill -0 #{pid} 2>/dev/null")
+            puts "优雅终止失败，使用强制终止..."
+            success = system("kill -KILL #{pid} 2>/dev/null")
+          end
+        end
+
+        if success
+          puts "✓ 进程 #{pid} 已终止"
+          sleep(1) # 等待端口释放
+
+          # 再次检查端口是否可用
+          unless port_occupied?(@server_port)
+            puts "✓ 端口 #{@server_port} 现在可用"
+            return true
+          else
+            puts "⚠️  端口仍被占用，可能需要等待更长时间"
+            return false
+          end
+        else
+          puts "✗ 终止进程失败，可能需要管理员权限"
+          return false
+        end
+      rescue => e
+        puts "终止进程时出错: #{e.message}"
+        return false
+      end
+    end
 
   end
 

data/lib/pindo/client/pgyerclient.rb

@@ -48,8 +48,8 @@ module Pindo
                 if @token["expires_at"] && Time.now.to_i < @token["expires_at"]
                     need_req_login = false
                 else
-                    Funlog.instance.fancyinfo_error("令牌已过期，需要重新登录...")
-                    login_success = true
+                    # 令牌过期，需要重新登录，但不显示错误消息
+                    need_req_login = true
                 end
             else
                 need_req_login = true
@@ -58,12 +58,22 @@ module Pindo
         if need_req_login
             login_handle = PgyerFeishuOAuthCLI.new("cli_a7db8213883ed00d")
             result = login_handle.authorize
-            @token = {}
-            @token["token"] = login_handle.access_token
-            @token["username"] = login_handle.username
-            @token["expires_at"] = login_handle.expires_at
-            store_token(token:@token)
-            login_success = true
+
+            # 处理用户取消的情况
+            if result == :user_cancelled
+                Funlog.instance.fancyinfo_error("用户取消了登录操作")
+                login_success = false
+            elsif result == true && login_handle.access_token
+                @token = {}
+                @token["token"] = login_handle.access_token
+                @token["username"] = login_handle.username
+                @token["expires_at"] = login_handle.expires_at
+                store_token(token:@token)
+                login_success = true
+            else
+                Funlog.instance.fancyinfo_error("登录失败，未能获取有效token")
+                login_success = false
+            end
         else
             login_success = true
         end
@@ -75,7 +85,7 @@ module Pindo
       def load_token()
 
           @token = nil
-          Funlog.instance.fancyinfo_success("正在读取pgyer token...")
+          # 静默读取token，不显示过程
           if File.exist?(@pgyer_token_file)
               begin
                 data = File.read(@pgyer_token_file)
@@ -86,24 +96,23 @@ module Pindo
                 if !temp_token.nil? && !temp_token["token"].nil? && !temp_token["username"].nil?
                     # 检查token是否已过期
                     if temp_token["expires_at"] && Time.now.to_i > temp_token["expires_at"]
-                        Funlog.instance.fancyinfo_error("令牌已过期，需要重新登录...")
+                        # 过期时静默处理，将在登录时提示
                         return nil
                     end
-                    
+
                     @token = temp_token
-                    Funlog.instance.fancyinfo_success("读取pgyer token成功!")
+                    # 成功读取时不显示，保持界面清洁
                 end
               rescue => error
-                  puts error
-                  # puts "加载pgyer token 失败!!! "
+                  # 静默处理错误
                   if File.exist?(@pgyer_token_file)
                     FileUtils.rm_rf(@pgyer_token_file)
                   end
-                  Funlog.instance.fancyinfo_error("pgyer token文件不存在!")
-                  @token  = nil
+                  @token = nil
               end
           else
-              Funlog.instance.fancyinfo_error("pgyer token文件不存在!")
+              # token文件不存在时静默处理，将在需要时自动登录
+              @token = nil
           end
         #   puts "token: #{@token}"
           return @token
@@ -118,10 +127,11 @@ module Pindo
             File.open(@pgyer_token_file, "w") do |f|
               f.write(data_string)
             end
-            Funlog.instance.fancyinfo_success("token 存储成功!")
-            # puts "store pgyer token---- sucess !!!"
+            # 静默存储，不显示消息
+            # Funlog.instance.fancyinfo_success("token 存储成功!")
           rescue => error
-            Funlog.instance.fancyinfo_error("token存储失败!")
+            # 存储失败时静默处理，避免干扰用户
+            # Funlog.instance.fancyinfo_error("token存储失败!")
           end
       end