illusion-code 0.2.9__tar.gz → 0.2.10__tar.gz

{illusion_code-0.2.9 → illusion_code-0.2.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: illusion-code
-Version: 0.2.9
+Version: 0.2.10
 Summary: Open-source Python port of Claude Code - an AI-powered CLI coding assistant
 Project-URL: Homepage, https://github.com/YunTaiHua/illusion-code
 Project-URL: Repository, https://github.com/YunTaiHua/illusion-code

{illusion_code-0.2.9 → illusion_code-0.2.10}/frontend/terminal/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@illusion/terminal",
-  "version": "0.2.9",
+  "version": "0.2.10",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@illusion/terminal",
-      "version": "0.2.9",
+      "version": "0.2.10",
       "dependencies": {
         "chalk": "^5.6.2",
         "ink": "^5.1.0",

{illusion_code-0.2.9 → illusion_code-0.2.10}/frontend/terminal/package.json

@@ -24,5 +24,5 @@
     "tsx": "^4.19.2",
     "typescript": "^5.7.3"
   },
-  "version": "0.2.9"
+  "version": "0.2.10"
 }

{illusion_code-0.2.9 → illusion_code-0.2.10}/frontend/terminal/src/version.ts

@@ -6,4 +6,4 @@
  */
 
 /** 当前版本号 */
-export const VERSION = '0.2.9';
+export const VERSION = '0.2.10';

{illusion_code-0.2.9 → illusion_code-0.2.10}/frontend/web/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@illusion/web",
-  "version": "0.2.9",
+  "version": "0.2.10",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@illusion/web",
-      "version": "0.2.9",
+      "version": "0.2.10",
       "dependencies": {
         "highlight.js": "^11.11.0",
         "react": "^18.3.1",

{illusion_code-0.2.9 → illusion_code-0.2.10}/frontend/web/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@illusion/web",
-  "version": "0.2.9",
+  "version": "0.2.10",
   "private": true,
   "type": "module",
   "scripts": {

{illusion_code-0.2.9 → illusion_code-0.2.10}/frontend/web/src/version.ts

@@ -6,4 +6,4 @@
  */
 
 /** 当前版本号 */
-export const VERSION = '0.2.9';
+export const VERSION = '0.2.10';

{illusion_code-0.2.9 → illusion_code-0.2.10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "illusion-code"
-version = "0.2.9"
+version = "0.2.10"
 description = "Open-source Python port of Claude Code - an AI-powered CLI coding assistant"
 readme = "README.md"
 license = "MIT"

{illusion_code-0.2.9 → illusion_code-0.2.10}/src/illusion/__init__.py

@@ -23,4 +23,4 @@ IllusionCode 是一个 AI 驱动的编程助手，提供交互式会话和命令
 
 from __future__ import annotations
 
-__version__ = "0.2.9"
+__version__ = "0.2.10"

{illusion_code-0.2.9 → illusion_code-0.2.10}/src/illusion/channels/__init__.py

@@ -173,6 +173,68 @@ def kill_channel_daemon(proc: "subprocess.Popen[bytes] | None") -> None:
             pass
 
 
+def is_channel_daemon_running() -> bool:
+    """检查渠道守护进程是否正在运行（通过 PID 文件，不依赖 proc 引用）
+
+    用于退出时判断是否需要询问用户是否一同退出渠道。
+
+    Returns:
+        bool: 守护进程在运行返回 True
+    """
+    from illusion.config.paths import get_channels_data_dir
+    from illusion.channels.pid import PidFile
+    pid_file = PidFile(get_channels_data_dir() / "daemon.pid")
+    return pid_file.is_running()
+
+
+def stop_channel_daemon_by_pid() -> bool:
+    """通过 PID 文件停止渠道守护进程（不依赖 proc 引用）
+
+    供退出时交互式确认使用：无论当前进程是否是 spawn 者，
+    都可以通过 PID 文件停止守护进程。
+
+    Windows 上用 taskkill /T /F 终止整个进程树（守护进程可能 spawn 了
+    aiohttp/WS 子线程，单独 TerminateProcess 可能留下孤儿线程）。
+    Unix 上用 SIGTERM 终止进程组。
+
+    Returns:
+        bool: 成功停止返回 True，守护进程不存在或已停止返回 False
+    """
+    from illusion.config.paths import get_channels_data_dir
+    from illusion.channels.pid import PidFile, read_pid
+
+    pid_file = PidFile(get_channels_data_dir() / "daemon.pid")
+    if not pid_file.is_running():
+        pid_file.release()
+        return False
+
+    old_pid = read_pid(pid_file.path)
+    if old_pid is not None:
+        try:
+            if os.name == "nt":
+                # Windows: 用 taskkill /T /F 终止整个进程树
+                # /T = 终止子进程，/F = 强制终止
+                import subprocess as _sp
+                _sp.run(
+                    ["taskkill", "/PID", str(old_pid), "/T", "/F"],
+                    capture_output=True, timeout=5,
+                )
+            else:
+                # Unix: 用 SIGTERM 终止进程组
+                import signal
+                os.kill(old_pid, signal.SIGTERM)
+        except (OSError, ProcessLookupError, Exception):  # noqa: BLE001
+            pass
+        # 等待进程退出，最多 3 秒
+        for _ in range(30):
+            if not pid_file.is_running():
+                break
+            import time as _time
+            _time.sleep(0.1)
+    pid_file.release()
+    return True
+
+
 class ChannelRunner:
     """渠道消息接入 agent 的运行器
 
@@ -210,6 +272,8 @@ class ChannelRunner:
         # 按 chat_id 串行化 agent turn，避免并行消息导致会话历史覆盖
         # （同一会话连发多条消息时，M2/M3 排队等 M1 完成后再跑）
         self._chat_locks: dict[str, asyncio.Lock] = {}
+        # 当前正在运行的 agent task（按 chat_id 索引），供 /stop 中断
+        self._active_agent_tasks: dict[str, asyncio.Task[None]] = {}
         self._stop = False
 
     def _get_chat_lock(self, chat_id: str) -> asyncio.Lock:
@@ -255,6 +319,8 @@ class ChannelRunner:
             msg: 入站消息
         """
         # 检查 /delete 信号：先执行 /new（清所有会话+发确认），再处理消息
+        # 信号触发后直接 return，避免继续走 try_handle 处理 /new 命令
+        # 导致"已开启新的对话"反馈消息发送两次
         if self.session_store.check_signal():
             for path in self.session_store.data_dir.glob("*.json"):
                 try:
@@ -267,6 +333,7 @@ class ChannelRunner:
                 msg.chat_id, _t("cmd_new"), reply_to=msg.message_id,
             )
             self.session_store.clear_signal()
+            return
 
         # 1. 待回复的权限/询问——不加锁，让回复立即送达
         # （agent turn 持锁等待回复时，下一条消息作为回复立即 set_result，
@@ -277,6 +344,13 @@ class ChannelRunner:
                 fut.set_result(msg.text)
             return
 
+        # /stop 命令：立即中断当前 chat_id 正在运行的 agent task，不排队等锁
+        # 必须在 _chat_locks 之前处理，否则会卡在串行队列里等到 agent 完成才生效
+        text = msg.text.strip()
+        if text.lower() == "/stop":
+            await self._handle_stop(msg)
+            return
+
         # 2/3. 斜杠命令 + agent turn：按 chat_id 串行化
         async with self._get_chat_lock(msg.chat_id):
             # 进入锁后再次检查 pending_replies：前一个 agent turn 可能
@@ -293,14 +367,33 @@ class ChannelRunner:
                 return
 
             # 3. 跑 agent
+            # 将当前 task 注册到 _active_agent_tasks，供 /stop 中断
+            current_task = asyncio.current_task()
+            if current_task is not None:
+                self._active_agent_tasks[msg.chat_id] = current_task
             try:
                 await self._run_agent(msg)
+            except asyncio.CancelledError:
+                # /stop 取消：agent 已中断，发提示消息
+                from illusion.config.i18n import t as _t
+                logger.info("agent 任务被 /stop 中断: chat_id=%s", msg.chat_id)
+                try:
+                    await self.channel.send_text(
+                        msg.chat_id, _t("cmd_stop_done"),
+                        reply_to=msg.message_id,
+                    )
+                except Exception:  # noqa: BLE001
+                    pass
+                raise
             except Exception as exc:  # noqa: BLE001
                 logger.exception("处理渠道消息异常: %s", exc)
                 try:
                     await self.channel.send_text(msg.chat_id, f"❌ 处理失败: {str(exc)[:100]}")
                 except Exception:  # noqa: BLE001
                     pass
+            finally:
+                # 清理 task 注册（无论正常完成、异常还是取消）
+                self._active_agent_tasks.pop(msg.chat_id, None)
 
     def _get_command_handler(self) -> Any:
         """按渠道类型返回对应的斜杠命令处理器
@@ -328,6 +421,31 @@ class ChannelRunner:
             pass  # QQ 模块不可用时跳过
         return None
 
+    async def _handle_stop(self, msg: "InboundMessage") -> None:
+        """处理 /stop 命令：中断当前 chat_id 正在运行的 agent 任务
+
+        不加 _chat_locks 锁，立即取消正在运行的 agent task。
+        如果没有正在运行的任务，回复提示"无正在执行的任务"。
+
+        Args:
+            msg: /stop 命令消息
+        """
+        from illusion.config.i18n import t as _t
+
+        task = self._active_agent_tasks.get(msg.chat_id)
+        if task is None or task.done():
+            # 无正在运行的任务
+            await self.channel.send_text(
+                msg.chat_id, _t("cmd_stop_no_task"),
+                reply_to=msg.message_id,
+            )
+            return
+
+        # 取消任务：触发 CancelledError，_run_agent 的 except 块清理流式控制器
+        # _handle_message 的 except CancelledError 块发送"已中断"提示
+        task.cancel()
+        logger.info("/stop 已取消 agent 任务: chat_id=%s", msg.chat_id)
+
     def _build_channel_tools(self, msg: "InboundMessage") -> list[Any]:
         """构造渠道内置工具列表
 
@@ -613,6 +731,20 @@ class ChannelRunner:
                     logger.warning("渠道会话持久化失败: %s", exc)
             else:
                 logger.warning("无法从 bundle.engine 获取会话历史，跳过持久化")
+        except asyncio.CancelledError:
+            # /stop 中断：清理流式控制器后重新抛出，让上层 _handle_message 发提示
+            logger.info("agent 任务被取消: chat_id=%s", msg.chat_id)
+            if supports_edit and streaming_controller:
+                try:
+                    await streaming_controller.error("已中断")
+                except Exception:  # noqa: BLE001
+                    pass
+            elif qq_streaming_controller:
+                try:
+                    await qq_streaming_controller.abort("已中断")
+                except Exception:  # noqa: BLE001
+                    pass
+            raise
         except Exception as exc:
             logger.exception("agent 处理异常")
             if supports_edit and streaming_controller:

{illusion_code-0.2.9 → illusion_code-0.2.10}/src/illusion/channels/base_commands.py

@@ -80,6 +80,10 @@ class BaseCommandHandler:
         elif cmd == "new":
             self.session_store.clear(key)
             await self._reply(msg, t("cmd_new"))
+        elif cmd == "stop":
+            # /stop 在 ChannelRunner._handle_message 开头已被拦截处理，
+            # 不会走到这里。此分支仅作为防御性兜底（如 PC 终端直接调用）
+            await self._reply(msg, t("cmd_stop_no_task"))
         elif cmd == "model":
             await self._cmd_model(msg, key, args)
         elif cmd == "sessions":

{illusion_code-0.2.9 → illusion_code-0.2.10}/src/illusion/channels/serve.py

@@ -32,6 +32,24 @@ def run_channel_serve() -> None:
     Windows 下 Ctrl+C 通过 KeyboardInterrupt 捕获，关闭后用 os._exit 确保退出
     （WS executor 线程可能无法干净终止）。
     """
+    # 启动前检查：若已有守护进程在运行（PID 文件指向存活进程），则拒绝启动
+    # 防止 maybe_spawn_channel_daemon 竞态条件导致两个守护进程同时运行
+    # （两个进程同时 spawn 时，PID 文件写入有竞态，可能都写入成功导致孤儿）
+    from illusion.config.paths import get_channels_data_dir
+    from illusion.channels.pid import PidFile, read_pid
+
+    data_dir = get_channels_data_dir()
+    pid_file = PidFile(data_dir / "daemon.pid")
+    if pid_file.is_running():
+        existing_pid = read_pid(pid_file.path) or 0
+        # 当前进程的 PID 与 PID 文件记录的不同 → 已有另一个守护进程在运行
+        if existing_pid and existing_pid != os.getpid():
+            print(
+                f"[channel] 守护进程已在运行 (PID={existing_pid})，拒绝重复启动。"
+                f" 若确信无进程在运行，请删除 {pid_file.path} 后重试。"
+            )
+            return
+
     cfg = load_channels_config()
     settings = _load_settings_safely()
 
@@ -101,6 +119,13 @@ def run_channel_serve() -> None:
     root_logger.addHandler(stream_handler)
     logger.info("渠道守护进程启动，日志文件: %s", log_path)
 
+    # 写入当前进程 PID 到 PID 文件（覆盖 maybe_spawn_channel_daemon 写入的 PID）
+    # 确保后续 maybe_spawn_channel_daemon 检查时能正确识别当前守护进程
+    try:
+        pid_file.acquire(os.getpid())
+    except Exception as exc:  # noqa: BLE001
+        logger.warning("写入 daemon.pid 失败: %s", exc)
+
     try:
         asyncio.run(_serve_async(cfg, settings))
     except KeyboardInterrupt:
@@ -109,6 +134,12 @@ def run_channel_serve() -> None:
         print("\n收到中断信号，正在关闭...")
         # 关闭资源后强制退出（WS executor 线程可能阻塞 os.kill 无法终止）
         _force_shutdown()
+    finally:
+        # 退出时释放 PID 文件，避免 maybe_spawn_channel_daemon 误判为仍在运行
+        try:
+            pid_file.release()
+        except Exception:  # noqa: BLE001
+            pass
 
 
 def _load_settings_safely() -> Any:

{illusion_code-0.2.9 → illusion_code-0.2.10}/src/illusion/cli.py

@@ -938,7 +938,6 @@ def web_start(
             typer.echo(_t("cwd_invalid", path=settings.working_directory), err=True)
 
     # 渠道自动激活：有 enabled 渠道时 spawn 守护进程（与 illusion 主命令一致）
-    from illusion.channels import kill_channel_daemon
     _daemon_proc = None
     try:
         from illusion.channels import maybe_spawn_channel_daemon
@@ -947,8 +946,42 @@ def web_start(
         import logging
         logging.getLogger(__name__).warning("渠道自动激活失败: %s", exc)
 
+    # PC 端渠道感知：与 illusion 主命令一致，注入 channel_hint + channel_tools
+    # 让 web 端 LLM 也能看到已启用渠道并用跨渠道工具发文件
+    pc_channel_hint: str | None = None
+    pc_channel_tools: list[Any] | None = None
+    try:
+        from illusion.channels.config import load_channels_config
+        from illusion.prompts.channel_hints import (
+            get_channel_hint,
+            list_active_sessions,
+        )
+        _cfg = load_channels_config()
+        if _cfg.has_enabled_channels():
+            other_names = _cfg.enabled_channel_names()
+            _active = {
+                name: list_active_sessions(name, _cfg, limit=5)
+                for name in other_names
+            }
+            pc_channel_hint = get_channel_hint(
+                current_channel=None,
+                channels_config=_cfg,
+                active_sessions=_active,
+            )
+            # 注入跨渠道工具
+            from illusion.channels.tools.cross_channel import (
+                ListChannelSessionsTool,
+                SendToChannelTool,
+            )
+            pc_channel_tools = [ListChannelSessionsTool(_cfg), SendToChannelTool(_cfg)]
+    except Exception as exc:  # noqa: BLE001
+        import logging
+        logging.getLogger(__name__).warning("PC 渠道感知加载失败: %s", exc)
+
     config = WebHostConfig(
         model=model,
+        channel_hint=pc_channel_hint,
+        channel_tools=pc_channel_tools,
     )
 
     app = create_app(dev=dev, host_config=config)
@@ -959,15 +992,29 @@ def web_start(
         import webbrowser
         threading.Thread(target=webbrowser.open, args=(url,), daemon=True).start()
 
-    # ctrl+c / 正常退出时终止渠道守护进程，避免孤儿进程
+    # ctrl+c / 正常退出时询问是否终止渠道守护进程（与 illusion 主命令一致）
+    # ctrl+c 触发时 force=True 直接停止守护进程
+    # 正常退出时询问用户（y/回车默认杀灭）
+    _interrupted = False
     try:
         uvicorn.run(app, host=host, port=port, log_level="warning")
+    except KeyboardInterrupt:
+        _interrupted = True
     finally:
-        if _daemon_proc is not None:
-            try:
-                kill_channel_daemon(_daemon_proc)
-            except Exception:  # noqa: BLE001
-                pass
+        try:
+            from illusion.channels import is_channel_daemon_running, stop_channel_daemon_by_pid
+            if is_channel_daemon_running():
+                if _interrupted:
+                    # ctrl+c 触发：直接停止守护进程
+                    stop_channel_daemon_by_pid()
+                else:
+                    # 正常退出：询问用户，y/回车默认杀灭
+                    from illusion.config.i18n import t
+                    answer = input(t("channel_daemon_exit_prompt") + " ").strip().lower()
+                    if answer in ("", "y", "yes"):
+                        stop_channel_daemon_by_pid()
+        except Exception:  # noqa: BLE001
+            pass
 
 
 # ---- update 子命令 ----
@@ -1306,7 +1353,6 @@ def main(
             )
 
     # 渠道自动激活：有 enabled 渠道时 spawn 守护进程
-    from illusion.channels import kill_channel_daemon
     _daemon_proc = None
     try:
         from illusion.channels import maybe_spawn_channel_daemon
@@ -1315,10 +1361,29 @@ def main(
         import logging
         logging.getLogger(__name__).warning("渠道自动激活失败: %s", exc)
 
-    def _kill_channel_daemon() -> None:
-        """退出时终止渠道守护进程（复用模块级函数，与 web 命令一致）"""
+    def _kill_channel_daemon(*, force: bool = False) -> None:
+        """退出时询问是否终止渠道守护进程
+
+        illusion 和 illusion web 可能同时运行并共享同一个守护进程。
+        退出时如果守护进程仍在运行，询问用户是否一同退出，避免
+        一个进程退出导致另一个进程失去渠道服务。
+
+        Args:
+            force: True 时直接停止守护进程（用于 ctrl+c 场景），False 时询问用户
+        """
         try:
-            kill_channel_daemon(_daemon_proc)
+            from illusion.channels import is_channel_daemon_running, stop_channel_daemon_by_pid
+            if not is_channel_daemon_running():
+                return
+            if force:
+                # ctrl+c 触发的退出：直接停止守护进程（用户已通过 ctrl+c 表达退出意图）
+                stop_channel_daemon_by_pid()
+                return
+            # 正常退出时询问用户；y 或直接回车（空输入）默认杀灭
+            from illusion.config.i18n import t
+            answer = input(t("channel_daemon_exit_prompt") + " ").strip().lower()
+            if answer in ("", "y", "yes"):
+                stop_channel_daemon_by_pid()
         except Exception:  # noqa: BLE001
             pass
 
@@ -1448,6 +1513,9 @@ def main(
         return
 
     # 启动交互式 REPL 会话
+    # ctrl+c 触发 KeyboardInterrupt 时，force=True 直接停止守护进程
+    # 正常退出时，询问用户是否一同退出渠道（y/回车默认杀灭）
+    _interrupted = False
     try:
         asyncio.run(
             run_repl(
@@ -1465,8 +1533,10 @@ def main(
                 channel_tools=pc_channel_tools,
             )
         )
+    except KeyboardInterrupt:
+        _interrupted = True
     finally:
-        _kill_channel_daemon()
+        _kill_channel_daemon(force=_interrupted)
 
 
 # ---- channel 子命令 ----

{illusion_code-0.2.9 → illusion_code-0.2.10}/src/illusion/config/i18n.py

@@ -209,10 +209,12 @@ MESSAGES: dict[str, dict[str, str]] = {
     "channel_disconnected": {"zh-CN": "未连接", "en-US": "disconnected"},
     # --- 飞书侧（用户在飞书中看到）---
     "feishu_thinking": {"zh-CN": "illusion code 正在思考中...", "en-US": "illusion code is thinking..."},
-    "feishu_cmd_help": {"zh-CN": "可用命令: /help /clear /new /delete /sessions /resume /detach /model", "en-US": "Commands: /help /clear /new /delete /sessions /resume /detach /model"},
+    "feishu_cmd_help": {"zh-CN": "可用命令: /help /clear /new /delete /stop /sessions /resume /detach /model", "en-US": "Commands: /help /clear /new /delete /stop /sessions /resume /detach /model"},
     "feishu_cmd_cleared": {"zh-CN": "飞书会话已清空，开始新对话。", "en-US": "Feishu session cleared, starting fresh."},
     # --- 通用渠道命令文案（不限渠道）---
     "cmd_new": {"zh-CN": "已开启新的会话。", "en-US": "New session started."},
+    "cmd_stop_no_task": {"zh-CN": "当前没有正在执行的任务。", "en-US": "No running task to stop."},
+    "cmd_stop_done": {"zh-CN": "已中断当前任务。", "en-US": "Task interrupted."},
     "feishu_cmd_sessions_title": {"zh-CN": "本地未完成会话:", "en-US": "Local unfinished sessions:"},
     "feishu_cmd_no_sessions": {"zh-CN": "没有本地会话可恢复。", "en-US": "No local sessions to resume."},
     "feishu_cmd_resumed": {"zh-CN": "已恢复本地会话（{n} 条历史），继续吧。", "en-US": "Resumed local session ({n} messages), continue."},
@@ -242,6 +244,11 @@ MESSAGES: dict[str, dict[str, str]] = {
         "zh-CN": "请先访问 https://q.qq.com 注册机器人应用，获取 App ID 和 Client Secret",
         "en-US": "Please visit https://q.qq.com to register a bot app and obtain App ID and Client Secret",
     },
+    # 渠道守护进程退出确认
+    "channel_daemon_exit_prompt": {
+        "zh-CN": "渠道守护进程仍在运行，是否一同退出？(y/N)",
+        "en-US": "Channel daemon is still running. Stop it too? (y/N)",
+    },
 }
 
 # --- 命令描述翻译 ---

{illusion_code-0.2.9 → illusion_code-0.2.10}/src/illusion/ui/web/ws_host.py

@@ -106,6 +106,9 @@ class WebHostConfig:
     restore_session_id: str | None = None
     enforce_max_turns: bool = True
     effort: str | None = None
+    # 渠道感知：与 illusion 主命令一致，注入渠道提示词和跨渠道工具
+    channel_hint: str | None = None
+    channel_tools: list[Any] | None = None
 
 
 class WebBackendHost:
@@ -168,6 +171,8 @@ class WebBackendHost:
                 ask_user_prompt=self._ask_question,  # type: ignore[arg-type]
                 plan_approval_prompt=self._ask_plan_approval,
                 effort=self._config.effort,
+                channel_hint=self._config.channel_hint,
+                channel_tools=self._config.channel_tools,
             )
         except Exception as exc:
             log.exception("Failed to build runtime")