myagent-ai 1.23.27 → 1.23.29

package/agents/main_agent.py

@@ -47,12 +47,12 @@ class MainAgent(BaseAgent):
 <output>
 <mainsubject>当前对话的6字以内标题（每轮都需输出，系统会每3轮自动更新会话名称）</mainsubject>
 <usersays_correct>通过修正识别错误、调整标点，结合上下文，将用户语音转写文本"usersays"修正为更准确的文本，但尽量少改动。如"usersays"为空，则此处为空。</usersays_correct>
-<response><reply>展示给用户的文本,格式上尽量使用md格式，直观形象展示，甚至可以包括超链接等。内容上，直接回应用户问题；告诉用户，为完成任务，准备如何开展工作；根据工具调用结果，展示任务进展；任务完成后的最终总结。注意:这是给用户展示信息的最重要标签，内容清晰明了，尽量不要跟上次回复重复。</reply><toolstocal>
-<tool><beforecalltext>展示给用户的简单工具调用信息。格式:先使用"接下来、下一步、接着、现在、然后、最后"等连接词➕调用"工具名"。</beforecalltext><toolname>工具名，用于后台解析器解析调用工具</toolname><parms>调用工具的JSON格式参数对象，如格式: {"query": "搜索关键词", "num": 5}</parms><timeout>预估调用超时时限(秒),工具调用超时会立即回调大语言模型，方便调整工具使用</timeout></tool>
+<response><reply>展示给用户的文本,格式上尽量使用md格式，直观形象展示，甚至可以包括超链接、表格等。内容上，针对用户问题，直接回应问题；针对任务，开始的时候，告诉用户，为完成任务，准备如何开展工作；执行过程中，根据工具调用结果，简单展示任务进展；任务完成后的详细最终总结。注意:这是给用户展示信息的最重要标签，尽量不要跟上次回复重复，执行过程展示内容尽量简洁，执行总结可以丰富一点。</reply><toolstocal>
+<tool><beforecalltext>展示给用户的简单工具调用信息。格式:先使用"接下来、下一步、接着、现在、然后、最后、等下"等连接词➕调用"工具名"。</beforecalltext><toolname>工具名，用于后台解析器解析调用工具</toolname><parms>调用工具的JSON格式参数对象，如格式: {"query": "搜索关键词", "num": 5}</parms><timeout>预估调用超时时限(秒),工具调用超时会立即回调大语言模型，方便调整工具使用</timeout></tool>
 </toolstocal>
 </response>
-<task_plan>若"context"包含非空"task_plan"，则更新它:若任务条数已超8，则精简为3条，若主题发生明显变化，重新设计任务列表。若"context"包含空"task_plan"，则先评估任务复杂度，针对单次查询、简单问答、格式转换、单文件修改、简单计算等简单任务，若预计操作步骤不超过2步，则此处输出为空，不创建任务列表；针对多文件修改、需要调研+实现+测试、涉及多个模块联动等复杂任务，如预计超过2步操作，则以Markdown列表格式制定新任务列表。格式：每项用 "- [ ] 任务描述" 或 "- [x] 已完成任务"，含完成状态标记。</task_plan>
-<remember><type>填global或session，其中"global"为跨会话全局记忆，"session"为仅当前会话。</type><content>仅从最新用户输入，包括"userprint"或"usersays_correct"或工具调用结果，中提炼值得记忆的信息（如用户偏好、重要结论、错误经验、用户个人信息、对话要点、用户诉求、ai回复等）。因为对话默认不自动保存聊天记录，而是从记忆库搜索最相关的最新内容到"automemory"供决策，所以此次必须有所记忆，才能为后续多轮对话提供持续记忆基础。</content></remember>
+<task_plan>若"context"包含非空"task_plan"，则更新它:若任务条数已超8，则精简为3条，若主题发生明显变化，重新设计任务列表。若"context"包含空"task_plan"，则先评估任务复杂度，针对单次查询、简单问答、格式转换、单文件修改、简单计算等简单任务，若预计操作步骤不超过2步，则此处输出为空，不创建任务列表；针对多文件修改、需要调研+实现+测试、涉及多个模块联动等复杂任务，如预计超过2步操作，则以Markdown列表格式制定新任务列表。格式：每项用 "- [ ] 任务描述" 或 "- [x] 已完成任务"，含完成状态标记，排序按已完成在前。</task_plan>
+<remember><type>填global或session，其中"global"为跨会话全局记忆，主要记忆用户个人信息和偏好，"session"为仅当前会话，临时的一些信息。</type><content>仅从最新用户输入，包括"userprint"或"usersays_correct"或工具调用结果，中提炼值得记忆的信息（如用户偏好、重要结论、错误经验、用户个人信息、对话要点、用户诉求、ai回复等）。因为对话默认不自动保存聊天记录，而是从记忆库搜索最相关的最新内容到"automemory"供决策，所以此次必须有所记忆，才能为后续多轮对话提供持续记忆基础。</content></remember>
 <recall>下一轮需要主动召回的记忆描述。填写需要从记忆库中检索的关键字或描述。如果不填写则为空。如果需要更多记忆支持当前任务，填写相关关键词（可包含时间参考，如"2025年1月的项目"），系统将在下一轮搜索top5相关记忆并通过"recall_memory"注入上下文。如需即时搜索记忆，使用命令: myagent-ai memory --keyword 关键词</recall>
 <knowledge>从本轮对话或工具执行结果中提炼值得长期保存到知识库的专业知识、事实、经验法则、技术要点等，将被持久化存储，未来可通过 "get_knowledge"检索复用。如果本轮无需保存的知识，则为空。格式要求：简洁明确，每条知识一行，用换行分隔。</knowledge>
 <get_knowledge>下一轮执行时需要从知识库搜索获得的知识，填写检索关键词或描述。如context中已包含充足的knowledge内容，则为空。如需更多专业知识支撑，则填写相关搜索词。</get_knowledge>
@@ -134,6 +134,9 @@ class MainAgent(BaseAgent):
 【记忆】
 - 搜索记忆: myagent-ai memory [--keyword 关键词] [--limit N]
 
+【Agent间通信】
+- 向其他Agent发送消息: myagent-ai chat --agent <Agent路径> --message "消息内容"
+
 【媒体播放】
 - 播放音频: myagent-ai playaudio --url 音频URL [--title 标题] 或 myagent-ai playaudio --file 本地路径
 - 播放视频: myagent-ai playvideo --url 视频URL [--title 标题] 或 myagent-ai playvideo --file 本地路径
@@ -149,6 +152,7 @@ class MainAgent(BaseAgent):
   <tool><toolname>command</toolname><parms>{"command": "myagent-ai ppt-create -s '{JSON幻灯片}'"}</parms><timeout>30</timeout></tool>
   <tool><toolname>command</toolname><parms>{"command": "myagent-ai playaudio --url https://music.163.com/song?id=123 --title 歌曲名"}</parms><timeout>10</timeout></tool>
   <tool><toolname>command</toolname><parms>{"command": "myagent-ai playvideo --url https://www.bilibili.com/video/BV123 --title 视频名"}</parms><timeout>10</timeout></tool>
+  <tool><toolname>command</toolname><parms>{"command": "myagent-ai chat --agent default/coder --message \"请帮我分析这段代码的时间复杂度\""}</parms><timeout>10</timeout></tool>
 
 多个命令可用 && 连接一次执行（强烈推荐，减少LLM回调次数）:
   <tool><toolname>command</toolname><parms>{"command": "myagent-ai search xxx && myagent-ai read-url https://..."}</parms><timeout>30</timeout></tool>
@@ -173,12 +177,12 @@ class MainAgent(BaseAgent):
 <output>
 <mainsubject>当前对话的6字以内标题（每轮都需输出，系统会每3轮自动更新会话名称）</mainsubject>
 <usersays_correct>通过修正识别错误、调整标点，结合上下文，将用户语音转写文本"usersays"修正为更准确的文本，但尽量少改动。如"usersays"为空，则此处为空。</usersays_correct>
-<response><reply>展示给用户的文本,格式上尽量使用md格式，直观形象展示，甚至可以包括超链接等。内容上，直接回应用户问题；告诉用户，为完成任务，准备如何开展工作；根据工具调用结果，展示任务进展；任务完成后的最终总结。注意:这是给用户展示信息的最重要标签，内容清晰明了，尽量不要跟上次回复重复。</reply><toolstocal>
-<tool><beforecalltext>展示给用户的简单工具调用信息。格式:先使用"接下来、下一步、接着、现在、然后、最后"等连接词➕调用"工具名"。</beforecalltext><toolname>工具名，用于后台解析器解析调用工具</toolname><parms>调用工具的JSON格式参数对象，如格式: {"query": "搜索关键词", "num": 5}</parms><timeout>预估调用超时时限(秒),工具调用超时会立即回调大语言模型，方便调整工具使用</timeout></tool>
+<response><reply>展示给用户的文本,格式上尽量使用md格式，直观形象展示，甚至可以包括超链接、表格等。内容上，针对用户问题，直接回应问题；针对任务，开始的时候，告诉用户，为完成任务，准备如何开展工作；执行过程中，根据工具调用结果，简单展示任务进展；任务完成后的详细最终总结。注意:这是给用户展示信息的最重要标签，尽量不要跟上次回复重复，执行过程展示内容尽量简洁，执行总结可以丰富一点。</reply><toolstocal>
+<tool><beforecalltext>展示给用户的简单工具调用信息。格式:先使用"接下来、下一步、接着、现在、然后、最后、等下"等连接词➕调用"工具名"。</beforecalltext><toolname>工具名，用于后台解析器解析调用工具</toolname><parms>调用工具的JSON格式参数对象，如格式: {"query": "搜索关键词", "num": 5}</parms><timeout>预估调用超时时限(秒),工具调用超时会立即回调大语言模型，方便调整工具使用</timeout></tool>
 </toolstocal>
 </response>
-<task_plan>若"context"包含非空"task_plan"，则更新它:若任务条数已超8，则精简为3条，若主题发生明显变化，重新设计任务列表。若"context"包含空"task_plan"，则先评估任务复杂度，针对单次查询、简单问答、格式转换、单文件修改、简单计算等简单任务，若预计操作步骤不超过2步，则此处输出为空，不创建任务列表；针对多文件修改、需要调研+实现+测试、涉及多个模块联动等复杂任务，如预计超过2步操作，则以Markdown列表格式制定新任务列表。格式：每项用 "- [ ] 任务描述" 或 "- [x] 已完成任务"，含完成状态标记。</task_plan>
-<remember><type>填global或session，其中"global"为跨会话全局记忆，"session"为仅当前会话。</type><content>仅从最新用户输入，包括"userprint"或"usersays_correct"或工具调用结果，中提炼值得记忆的信息（如用户偏好、重要结论、错误经验、用户个人信息、对话要点、用户诉求、ai回复等）。因为对话默认不自动保存聊天记录，而是从记忆库搜索最相关的最新内容到"automemory"供决策，所以此次必须有所记忆，才能为后续多轮对话提供持续记忆基础。</content></remember>
+<task_plan>若"context"包含非空"task_plan"，则更新它:若任务条数已超8，则精简为3条，若主题发生明显变化，重新设计任务列表。若"context"包含空"task_plan"，则先评估任务复杂度，针对单次查询、简单问答、格式转换、单文件修改、简单计算等简单任务，若预计操作步骤不超过2步，则此处输出为空，不创建任务列表；针对多文件修改、需要调研+实现+测试、涉及多个模块联动等复杂任务，如预计超过2步操作，则以Markdown列表格式制定新任务列表。格式：每项用 "- [ ] 任务描述" 或 "- [x] 已完成任务"，含完成状态标记，排序按已完成在前。</task_plan>
+<remember><type>填global或session，其中"global"为跨会话全局记忆，主要记忆用户个人信息和偏好，"session"为仅当前会话，临时的一些信息。</type><content>仅从最新用户输入，包括"userprint"或"usersays_correct"或工具调用结果，中提炼值得记忆的信息（如用户偏好、重要结论、错误经验、用户个人信息、对话要点、用户诉求、ai回复等）。因为对话默认不自动保存聊天记录，而是从记忆库搜索最相关的最新内容到"automemory"供决策，所以此次必须有所记忆，才能为后续多轮对话提供持续记忆基础。</content></remember>
 <recall>下一轮需要主动召回的记忆描述。填写需要从记忆库中检索的关键字或描述。如果不填写则为空。如果需要更多记忆支持当前任务，填写相关关键词（可包含时间参考，如"2025年1月的项目"），系统将在下一轮搜索top5相关记忆并通过"recall_memory"注入上下文。如需即时搜索记忆，使用命令: myagent-ai memory --keyword 关键词</recall>
 <knowledge>从本轮对话或工具执行结果中提炼值得长期保存到知识库的专业知识、事实、经验法则、技术要点等，将被持久化存储，未来可通过 "get_knowledge"检索复用。如果本轮无需保存的知识，则为空。格式要求：简洁明确，每条知识一行，用换行分隔。</knowledge>
 <get_knowledge>下一轮执行时需要从知识库搜索获得的知识，填写检索关键词或描述。如context中已包含充足的knowledge内容，则为空。如需更多专业知识支撑，则填写相关搜索词。</get_knowledge>

package/core/tool_dispatcher.py

@@ -246,6 +246,31 @@ class ToolDispatcher:
                 if not media_result.get("success"):
                     result["output"] += f"\n[视频播放失败: {media_result.get('error', '')}]"
 
+        # [v1.23.29] 检测 __CHAT_AGENT__ 标记 — CLI chat 命令输出此标记
+        # 格式: __CHAT_AGENT__agent_path|agent_name|message__END__
+        chat_markers = _re.findall(r'__CHAT_AGENT__(.+?)\|(.+?)\|(.+?)__END__', clean_output)
+        if chat_markers:
+            clean_output = _re.sub(r'__CHAT_AGENT__.+?__END__\n?', '', clean_output).strip()
+            result["output"] = clean_output
+            for chat_agent_path, chat_agent_name, chat_msg in chat_markers:
+                # Store as a chat agent event in sent_files for persistence
+                if sent_files is not None:
+                    sent_files.append({
+                        "_type": "chat_agent",
+                        "target_agent": chat_agent_path.strip(),
+                        "target_name": chat_agent_name.strip(),
+                        "message": chat_msg.strip(),
+                    })
+                # Emit SSE event for frontend display
+                try:
+                    await self._emit_sse("v2_chat_agent", {
+                        "target_agent": chat_agent_path.strip(),
+                        "target_name": chat_agent_name.strip(),
+                        "message": chat_msg.strip(),
+                    }, stream_callback)
+                except Exception:
+                    pass
+
         return result
 
     async def _exec_recall_memory(self, params: Dict, task_id: str) -> Dict:
@@ -284,7 +309,15 @@ class ToolDispatcher:
             fskill = FileSendSkill()
             fpath = params.get("file_path", "")
             fdesc = params.get("description", "")
+            if not fpath:
+                logger.warning(f"[{task_id}] file_send: 缺少 file_path 参数")
+                return {"success": False, "error": "缺少 file_path 参数，请提供要发送的文件路径"}
+            logger.info(f"[{task_id}] file_send: 发送文件 {fpath}")
             fresult = await fskill.execute(fpath, fdesc, stream_callback=stream_callback)
+            if not fresult.get("success"):
+                logger.warning(f"[{task_id}] file_send: 发送失败 - {fresult.get('error', '')}")
+            else:
+                logger.info(f"[{task_id}] file_send: 发送成功 {fresult.get('file_id', '')} → {fresult.get('name', '')}")
             result = {"success": True, "output": json.dumps(fresult, ensure_ascii=False, indent=2), "data": fresult}
             if sent_files is not None and fresult.get("success") and fresult.get("file_id"):
                 sent_files.append({
@@ -295,6 +328,7 @@ class ToolDispatcher:
                 })
             return result
         except Exception as e:
+            logger.error(f"[{task_id}] file_send: 异常 - {e}", exc_info=True)
             return {"success": False, "error": f"文件发送失败: {e}"}
 
     async def _exec_media(
@@ -310,6 +344,10 @@ class ToolDispatcher:
         embed_title = params.get("title", "")
         fallback_link = None
 
+        if not media_url and not media_file:
+            logger.warning(f"[{task_id}] {tool_name}: 缺少 url 和 file_path 参数")
+            return {"success": False, "error": f"请提供在线链接(url)或本地文件路径(file_path)"}
+
         if media_url:
             url_lower = media_url.lower()
             # YouTube
@@ -378,6 +416,7 @@ class ToolDispatcher:
             sent_files.append(_media_meta)
 
         if embed_url and stream_callback:
+            logger.info(f"[{task_id}] {tool_name}: 嵌入播放器 {embed_title} → {embed_url[:80]}")
             await self._emit_sse("v2_media", {
                 "media_type": media_type,
                 "embed_url": embed_url,
@@ -386,6 +425,11 @@ class ToolDispatcher:
             }, stream_callback)
             return {"success": True, "output": f"已嵌入{embed_title}播放器: {media_url}"}
 
+        elif embed_url and not stream_callback:
+            # [v1.23.26] stream_callback 缺失时仍返回成功（非 Web 环境降级）
+            logger.warning(f"[{task_id}] {tool_name}: stream_callback 缺失，无法发送播放器到前端")
+            return {"success": True, "output": f"已生成{embed_title}播放器（非 Web 环境无法显示）: {embed_url}"}
+
         elif fallback_link and stream_callback:
             await self._emit_sse("v2_media", {
                 "media_type": media_type,

package/core/web_control.py

@@ -531,6 +531,11 @@ class WebControlManager:
 
         import aiohttp
 
+        # [v1.23.26] 兼容不同 aiohttp 版本的 redirect 参数
+        # aiohttp >= 3.0 使用 follow_redirects, < 3.0 使用 allow_redirects
+        _aio_ver = tuple(int(x) for x in aiohttp.__version__.split('.')[:2])
+        _redirect_kw = 'follow_redirects' if _aio_ver >= (3, 0) else 'allow_redirects'
+
         headers = {
             'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
             'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8',
@@ -559,7 +564,7 @@ class WebControlManager:
                 async with http_session.get(
                     url,
                     headers=headers,
-                    follow_redirects=True,
+                    **{_redirect_kw: True},
                     timeout=aiohttp.ClientTimeout(total=20),
                     ssl=False,
                 ) as resp:

package/data/novnc/lib/base64.js

@@ -1,18 +1,18 @@
 "use strict";
 
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports["default"] = void 0;
 var Log = _interopRequireWildcard(require("./util/logging.js"));
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 // From: http://hg.mozilla.org/mozilla-central/raw-file/ec10630b1a54/js/src/devtools/jint/sunspider/string-base64.js
-var _default = exports["default"] = {
+var _default = {
   /* Convert data (an array of integers) to a Base64 string. */
   toBase64Table: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='.split(''),
   base64Pad: '=',
@@ -97,4 +97,5 @@ var _default = exports["default"] = {
     return result;
   }
 };
-/* End of Base64 namespace */
+/* End of Base64 namespace */
+exports["default"] = _default;

package/data/novnc/lib/decoders/copyrect.js

@@ -4,12 +4,12 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports["default"] = void 0;
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
-function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
-function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
 /*
  * noVNC: HTML5 VNC client
  * Copyright (C) 2019 The noVNC Authors
@@ -18,11 +18,11 @@ function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e
  * See README.md for usage and integration instructions.
  *
  */
-var CopyRectDecoder = exports["default"] = /*#__PURE__*/function () {
+var CopyRectDecoder = /*#__PURE__*/function () {
   function CopyRectDecoder() {
     _classCallCheck(this, CopyRectDecoder);
   }
-  return _createClass(CopyRectDecoder, [{
+  _createClass(CopyRectDecoder, [{
     key: "decodeRect",
     value: function decodeRect(x, y, width, height, sock, display, depth) {
       if (sock.rQwait("COPYRECT", 4)) {
@@ -37,4 +37,6 @@ var CopyRectDecoder = exports["default"] = /*#__PURE__*/function () {
       return true;
     }
   }]);
-}();
+  return CopyRectDecoder;
+}();
+exports["default"] = CopyRectDecoder;

package/data/novnc/lib/decoders/hextile.js

@@ -5,29 +5,22 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports["default"] = void 0;
 var Log = _interopRequireWildcard(require("../util/logging.js"));
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
-function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
-function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } /*
- * noVNC: HTML5 VNC client
- * Copyright (C) 2019 The noVNC Authors
- * Licensed under MPL 2.0 (see LICENSE.txt)
- *
- * See README.md for usage and integration instructions.
- *
- */
-var HextileDecoder = exports["default"] = /*#__PURE__*/function () {
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+var HextileDecoder = /*#__PURE__*/function () {
   function HextileDecoder() {
     _classCallCheck(this, HextileDecoder);
     this._tiles = 0;
     this._lastsubencoding = 0;
     this._tileBuffer = new Uint8Array(16 * 16 * 4);
   }
-  return _createClass(HextileDecoder, [{
+  _createClass(HextileDecoder, [{
     key: "decodeRect",
     value: function decodeRect(x, y, width, height, sock, display, depth) {
       if (this._tiles === 0) {
@@ -41,7 +34,9 @@ var HextileDecoder = exports["default"] = /*#__PURE__*/function () {
         if (sock.rQwait("HEXTILE", bytes)) {
           return false;
         }
-        var subencoding = sock.rQpeek8();
+        var rQ = sock.rQ;
+        var rQi = sock.rQi;
+        var subencoding = rQ[rQi]; // Peek
         if (subencoding > 30) {
           // Raw
           throw new Error("Illegal hextile subencoding (subencoding: " + subencoding + ")");
@@ -74,7 +69,7 @@ var HextileDecoder = exports["default"] = /*#__PURE__*/function () {
             if (sock.rQwait("HEXTILE", bytes)) {
               return false;
             }
-            var subrects = sock.rQpeekBytes(bytes).at(-1);
+            var subrects = rQ[rQi + bytes - 1]; // Peek
             if (subencoding & 0x10) {
               // SubrectsColoured
               bytes += subrects * (4 + 2);
@@ -88,7 +83,7 @@ var HextileDecoder = exports["default"] = /*#__PURE__*/function () {
         }
 
         // We know the encoding and have a whole tile
-        sock.rQshift8();
+        rQi++;
         if (subencoding === 0) {
           if (this._lastsubencoding & 0x01) {
             // Weird: ignore blanks are RAW
@@ -99,37 +94,43 @@ var HextileDecoder = exports["default"] = /*#__PURE__*/function () {
         } else if (subencoding & 0x01) {
           // Raw
           var pixels = tw * th;
-          var data = sock.rQshiftBytes(pixels * 4, false);
           // Max sure the image is fully opaque
           for (var i = 0; i < pixels; i++) {
-            data[i * 4 + 3] = 255;
+            rQ[rQi + i * 4 + 3] = 255;
           }
-          display.blitImage(tx, ty, tw, th, data, 0);
+          display.blitImage(tx, ty, tw, th, rQ, rQi);
+          rQi += bytes - 1;
         } else {
           if (subencoding & 0x02) {
             // Background
-            this._background = new Uint8Array(sock.rQshiftBytes(4));
+            this._background = [rQ[rQi], rQ[rQi + 1], rQ[rQi + 2], rQ[rQi + 3]];
+            rQi += 4;
           }
           if (subencoding & 0x04) {
             // Foreground
-            this._foreground = new Uint8Array(sock.rQshiftBytes(4));
+            this._foreground = [rQ[rQi], rQ[rQi + 1], rQ[rQi + 2], rQ[rQi + 3]];
+            rQi += 4;
           }
           this._startTile(tx, ty, tw, th, this._background);
           if (subencoding & 0x08) {
             // AnySubrects
-            var _subrects = sock.rQshift8();
+            var _subrects = rQ[rQi];
+            rQi++;
             for (var s = 0; s < _subrects; s++) {
               var color = void 0;
               if (subencoding & 0x10) {
                 // SubrectsColoured
-                color = sock.rQshiftBytes(4);
+                color = [rQ[rQi], rQ[rQi + 1], rQ[rQi + 2], rQ[rQi + 3]];
+                rQi += 4;
               } else {
                 color = this._foreground;
               }
-              var xy = sock.rQshift8();
+              var xy = rQ[rQi];
+              rQi++;
               var sx = xy >> 4;
               var sy = xy & 0x0f;
-              var wh = sock.rQshift8();
+              var wh = rQ[rQi];
+              rQi++;
               var sw = (wh >> 4) + 1;
               var sh = (wh & 0x0f) + 1;
               this._subTile(sx, sy, sw, sh, color);
@@ -137,6 +138,7 @@ var HextileDecoder = exports["default"] = /*#__PURE__*/function () {
           }
           this._finishTile(display);
         }
+        sock.rQi = rQi;
         this._lastsubencoding = subencoding;
         this._tiles--;
       }
@@ -192,4 +194,6 @@ var HextileDecoder = exports["default"] = /*#__PURE__*/function () {
       display.blitImage(this._tileX, this._tileY, this._tileW, this._tileH, this._tileBuffer, 0);
     }
   }]);
-}();
+  return HextileDecoder;
+}();
+exports["default"] = HextileDecoder;