pocket-coding 0.2.0__tar.gz → 0.2.1__tar.gz

{pocket_coding-0.2.0 → pocket_coding-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pocket-coding
-Version: 0.2.0
+Version: 0.2.1
 Summary: PoCo: Pocket Coding for Feishu
 Author: PoCo contributors
 Keywords: bot,codex,feishu,lark,tui

{pocket_coding-0.2.0 → pocket_coding-0.2.1}/poco/__init__.py

@@ -1,4 +1,4 @@
 """PoCo package."""
 
 __all__ = ["__version__"]
-__version__ = "0.2.0"
+__version__ = "0.2.1"

{pocket_coding-0.2.0 → pocket_coding-0.2.1}/poco/app.py

@@ -1,19 +1,47 @@
 #!/usr/bin/env python3
 import argparse
+import fcntl
 import json
 import logging
 import os
 import sys
 from logging.handlers import RotatingFileHandler
+from pathlib import Path
 from .bootstrap import run_feishu_bootstrap_cli
 from .runtime import (
     PoCoService,
     RingLogHandler,
 )
-from .config import CONFIG_PATH, LOG_PATH, ConfigStore, ensure_dirs, get_nested
+from .config import CONFIG_PATH, LOG_PATH, STATE_DIR, ConfigStore, ensure_dirs, get_nested
 from .tui import PoCoTui
 
 
+_APP_LOCK = None
+
+
+def _acquire_app_lock() -> bool:
+    """Acquires a process-wide PoCo instance lock.
+
+    Returns:
+        True when this process successfully acquired the lock, or False when
+        another PoCo process is already holding it.
+    """
+    global _APP_LOCK
+    lock_path = Path(STATE_DIR) / "poco.lock"
+    handle = lock_path.open("w", encoding="utf-8")
+    try:
+        fcntl.flock(handle.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+    except BlockingIOError:
+        handle.close()
+        return False
+    handle.seek(0)
+    handle.truncate()
+    handle.write(str(os.getpid()))
+    handle.flush()
+    _APP_LOCK = handle
+    return True
+
+
 def parse_args() -> argparse.Namespace:
     parser = argparse.ArgumentParser(description="PoCo")
     parser.add_argument("--log-level", default="INFO")
@@ -33,6 +61,8 @@ def main() -> None:
         format="%(asctime)s %(levelname)s %(name)s: %(message)s",
     )
     ensure_dirs()
+    if not _acquire_app_lock():
+        raise SystemExit("Another PoCo process is already running. Kill the existing process first.")
     root_logger = logging.getLogger()
     ring = RingLogHandler()
     ring.setFormatter(logging.Formatter("%(asctime)s %(levelname)s %(name)s: %(message)s"))

{pocket_coding-0.2.0 → pocket_coding-0.2.1}/poco/config/__init__.py

@@ -12,6 +12,7 @@ from .store import (
     ensure_dirs,
     get_nested,
     mask_secret,
+    missing_required_config_paths,
     normalize_config_key,
     parse_config_value,
     set_nested,
@@ -31,6 +32,7 @@ __all__ = [
     "ensure_dirs",
     "get_nested",
     "mask_secret",
+    "missing_required_config_paths",
     "normalize_config_key",
     "parse_config_value",
     "set_nested",

{pocket_coding-0.2.0 → pocket_coding-0.2.1}/poco/config/store.py

@@ -197,6 +197,24 @@ def config_ready(config: Dict[str, Any]) -> bool:
     return bool(feishu["app_id"] and feishu["app_secret"])
 
 
+def missing_required_config_paths(config: Dict[str, Any]) -> list[str]:
+    """Returns the required config paths that are still missing.
+
+    Args:
+        config: Current merged config payload.
+
+    Returns:
+        A list of dotted config paths that must be filled before PoCo can run.
+    """
+    missing: list[str] = []
+    feishu = config.get("feishu", {})
+    if not str(feishu.get("app_id", "")).strip():
+        missing.append("feishu.app_id")
+    if not str(feishu.get("app_secret", "")).strip():
+        missing.append("feishu.app_secret")
+    return missing
+
+
 def ensure_dirs() -> None:
     CONFIG_DIR.mkdir(parents=True, exist_ok=True)
     STATE_DIR.mkdir(parents=True, exist_ok=True)

{pocket_coding-0.2.0 → pocket_coding-0.2.1}/poco/providers/claude.py

@@ -185,7 +185,10 @@ class ClaudeProviderClient:
             cmd.extend(["--session-id", thread_id])
         if self._provider.model:
             cmd.extend(["--model", self._provider.model])
-        if self._provider.approval_policy:
+        approval_policy = self._provider.approval_policy.strip()
+        if approval_policy in {"bypassPermissions", "dangerously-skip-permissions"}:
+            cmd.append("--dangerously-skip-permissions")
+        elif approval_policy:
             cmd.extend(["--permission-mode", self._provider.approval_policy])
         image_paths = [path for path in (local_image_paths or []) if path]
         for parent in sorted({str(Path(path).expanduser().resolve().parent) for path in image_paths}):
@@ -203,6 +206,8 @@ class ClaudeProviderClient:
         cmd.append(text)
         env = os.environ.copy()
         env.update(self._provider.env)
+        if str(self._provider.sandbox).strip() in {"1", "true", "True", "sandbox", "is_sandbox"}:
+            env["IS_SANDBOX"] = "1"
         process = subprocess.Popen(
             cmd,
             stdin=subprocess.DEVNULL,

{pocket_coding-0.2.0 → pocket_coding-0.2.1}/poco/providers/codex.py

@@ -216,7 +216,7 @@ class CodexProviderClient:
         self._request(
             "initialize",
             {
-                "clientInfo": {"name": "poco-provider-bridge", "version": "0.2.0"},
+                "clientInfo": {"name": "poco-provider-bridge", "version": "0.2.1"},
                 "capabilities": {"experimentalApi": True},
             },
         )

{pocket_coding-0.2.0 → pocket_coding-0.2.1}/poco/relay/app.py

@@ -435,14 +435,9 @@ class RelayApp:
             self._safe_send(chat_id, "[poco] 单聊是管理控制台，暂不处理图片。请在项目群里发送图片。")
             return
         worker_id = chat_id
-        self._worker_store.ensure_worker(worker_id)
-        if not self._worker_store.enabled_for(worker_id):
-            self._safe_send(
-                chat_id,
-                "[poco] This group is not active yet.\n"
-                "Create and manage project groups from the DM console instead of configuring them here.\n"
-                "DM the bot with `poco`.",
-            )
+        state_error = self._group_access_error_text(worker_id)
+        if state_error:
+            self._safe_send(chat_id, state_error)
             return
         self._safe_send(
             chat_id,
@@ -468,14 +463,9 @@ class RelayApp:
             return
 
         worker_id = chat_id
-        self._worker_store.ensure_worker(worker_id)
-        if not self._worker_store.enabled_for(worker_id):
-            self._safe_send(
-                chat_id,
-                "[poco] This group is not active yet.\n"
-                "Create and manage project groups from the DM console instead.\n"
-                "DM the bot with `poco`.",
-            )
+        state_error = self._group_access_error_text(worker_id)
+        if state_error:
+            self._safe_send(chat_id, state_error)
             return
 
         local_image_paths = [
@@ -510,7 +500,6 @@ class RelayApp:
         open_id: str,
     ) -> None:
         worker_id = chat_id
-        self._worker_store.ensure_worker(worker_id)
         command, arg = self._parse_poco_command(text)
         stripped = text.strip().lower()
         if command == "cardtest":
@@ -525,13 +514,9 @@ class RelayApp:
                 "请去单聊发送 `poco`，这个群里直接聊天即可。",
             )
             return
-        if not self._worker_store.enabled_for(worker_id):
-            self._safe_send(
-                chat_id,
-                "[poco] This group is not active yet.\n"
-                "Create and manage project groups from the DM console.\n"
-                "DM the bot with `poco`.",
-            )
+        state_error = self._group_access_error_text(worker_id)
+        if state_error:
+            self._safe_send(chat_id, state_error)
             return
 
         self._handle_group_turn_input(worker_id, chat_id, chat_type, text, mentions, open_id)
@@ -720,8 +705,31 @@ class RelayApp:
                 cleaned = cleaned.replace(f"@{name}", " ")
         return " ".join(cleaned.split())
 
+    def _group_access_error_text(self, worker_id: str) -> Optional[str]:
+        if not self._worker_store.has_worker(worker_id):
+            if self._store.get(worker_id):
+                return (
+                    "[poco] This group's local project state is missing or corrupted.\n"
+                    "Please go back to the DM console and recreate or repair this project group."
+                )
+            return (
+                "[poco] This group is not active yet.\n"
+                "Create and manage project groups from the DM console.\n"
+                "DM the bot with `poco`."
+            )
+        if not self._worker_store.enabled_for(worker_id):
+            return (
+                "[poco] This group is not active yet.\n"
+                "Create and manage project groups from the DM console.\n"
+                "DM the bot with `poco`."
+            )
+        return None
+
     def _ensure_worker(self, worker_id: str, chat_id: str, chat_type: str) -> WorkerRuntime:
-        self._worker_store.ensure_worker(worker_id)
+        if not self._worker_store.has_worker(worker_id):
+            raise RuntimeError(
+                "当前群的本地项目状态缺失或损坏。请回到 DM 控制台重新创建或修复这个项目群。"
+            )
         cwd = self._worker_store.cwd_for(worker_id)
         provider_name = self._provider_name_for_worker(worker_id)
         if not provider_name:

{pocket_coding-0.2.0 → pocket_coding-0.2.1}/poco/relay/cards.py

@@ -861,6 +861,17 @@ class SetupCardController:
             payload["toast"] = {"type": toast_type, "content": notice}
         return P2CardActionTriggerResponse(payload)
 
+    @staticmethod
+    def response_toast(notice: str, toast_type: str = "info") -> P2CardActionTriggerResponse:
+        return P2CardActionTriggerResponse(
+            {
+                "toast": {
+                    "type": toast_type,
+                    "content": notice,
+                }
+            }
+        )
+
     @staticmethod
     def coerce_form_value(value: object) -> str:
         if value is None:
@@ -1086,6 +1097,33 @@ class SetupCardController:
                         "success",
                     )
 
+            if action_name == "stop_turn":
+                with self.app._lock:
+                    session = self.app._active_by_worker.get(worker_id)
+                    worker = self.app._workers.get(worker_id)
+                if session is None or worker is None:
+                    return self.response_toast("Nothing to stop.", "info")
+                try:
+                    worker.client.interrupt_turn(session.thread_id, session.turn_id)
+                except Exception as exc:
+                    return self.response_toast(f"Stop failed: {exc}", "error")
+                with session.lock:
+                    rendered = (session.final_text or session.accumulated_text).rstrip() or "_Stopped._"
+                    session.done = True
+                    session.final_text = rendered
+                    session.error_text = ""
+                    session.live.card_broken = True
+                session.notify()
+                return self.response_card(
+                    self.app._turns.answer_card(
+                        worker.provider_name,
+                        rendered,
+                        state="stopped",
+                        stop_enabled=False,
+                        streaming=False,
+                    ),
+                )
+
             if action_name in {"launch_project", "reset_project_launch"}:
                 def project_card_response(
                     notice: str = "",

{pocket_coding-0.2.0 → pocket_coding-0.2.1}/poco/relay/messenger.py

@@ -11,10 +11,13 @@ from typing import Dict, Optional
 import lark_oapi as lark
 from lark_oapi.api.cardkit.v1.model.content_card_element_request import ContentCardElementRequest
 from lark_oapi.api.cardkit.v1.model.content_card_element_request_body import ContentCardElementRequestBody
+from lark_oapi.api.cardkit.v1.model.card import Card
 from lark_oapi.api.cardkit.v1.model.create_card_request import CreateCardRequest
 from lark_oapi.api.cardkit.v1.model.create_card_request_body import CreateCardRequestBody
 from lark_oapi.api.cardkit.v1.model.settings_card_request import SettingsCardRequest
 from lark_oapi.api.cardkit.v1.model.settings_card_request_body import SettingsCardRequestBody
+from lark_oapi.api.cardkit.v1.model.update_card_request import UpdateCardRequest
+from lark_oapi.api.cardkit.v1.model.update_card_request_body import UpdateCardRequestBody
 from lark_oapi.api.im.v1 import (
     CreateChatMembersRequest,
     CreateChatMembersRequestBody,
@@ -383,6 +386,31 @@ class FeishuMessenger:
                 f"log_id={response.get_log_id()}"
             )
 
+    def update_card_entity(self, card_id: str, card: dict, sequence: int) -> None:
+        request = (
+            UpdateCardRequest.builder()
+            .card_id(card_id)
+            .request_body(
+                UpdateCardRequestBody.builder()
+                .uuid(str(uuid.uuid4()))
+                .sequence(sequence)
+                .card(
+                    Card.builder()
+                    .type("card_json")
+                    .data(json.dumps(card, ensure_ascii=False, separators=(",", ":")))
+                    .build()
+                )
+                .build()
+            )
+            .build()
+        )
+        response = self._client.cardkit.v1.card.update(request)
+        if response.code != 0:
+            raise RuntimeError(
+                f"Feishu update card entity failed: code={response.code}, msg={response.msg}, "
+                f"log_id={response.get_log_id()}"
+            )
+
     def update_text(self, message_id: str, text: str) -> None:
         request = (
             UpdateMessageRequest.builder()

{pocket_coding-0.2.0 → pocket_coding-0.2.1}/poco/relay/runtime.py

@@ -175,6 +175,19 @@ class TurnController:
                     )
                     live.stream_sequence += 1
                     live.streaming_mode = False
+                    self.app._messenger.update_card_entity(
+                        live.card_id,
+                        self.answer_card(
+                            self.app._provider_name_for_worker(session.worker_id),
+                            rendered,
+                            state="completed",
+                            stop_enabled=False,
+                            streaming=False,
+                            element_id=live.element_id or "answer_stream",
+                        ),
+                        live.stream_sequence + 1,
+                    )
+                    live.stream_sequence += 1
                 except Exception:
                     LOG.exception("Failed to close streaming mode for card_id=%s", live.card_id)
             return
@@ -301,38 +314,111 @@ class TurnController:
             streaming_mode=True,
         )
 
-    def create_streaming_answer_card(self, provider_name: str) -> Tuple[str, str]:
-        """Create a reusable streaming card entity for one answer."""
-        element_id = "answer_stream"
-        card = {
+    def answer_card(
+        self,
+        provider_name: str,
+        text: str,
+        *,
+        state: str,
+        stop_enabled: bool,
+        streaming: bool,
+        element_id: str = "answer_stream",
+    ) -> dict:
+        """Build one reply card for streaming, completed, or stopped states."""
+        normalized = state.strip().lower()
+        if normalized == "stopped":
+            template = "orange"
+            tag_text = "Stopped"
+            tag_color = "orange"
+        elif normalized == "completed":
+            template = "green"
+            tag_text = "Completed"
+            tag_color = "green"
+        else:
+            template = "orange"
+            tag_text = "Running"
+            tag_color = "blue"
+        elements = [
+            {
+                "tag": "markdown",
+                "element_id": element_id,
+                "content": text,
+            }
+        ]
+        if stop_enabled:
+            elements.append(
+                {
+                    "tag": "column_set",
+                    "horizontal_spacing": "8px",
+                    "columns": [
+                        {
+                            "tag": "column",
+                            "width": "auto",
+                            "elements": [
+                                self.app._card_button("Stop", "stop_turn", "default")
+                            ],
+                        }
+                    ],
+                }
+            )
+        elif normalized == "stopped":
+            elements.append(
+                {
+                    "tag": "column_set",
+                    "horizontal_spacing": "8px",
+                    "columns": [
+                        {
+                            "tag": "column",
+                            "width": "auto",
+                            "elements": [
+                                self.app._card_button("Stopped", "stopped", "default", enable_callback=False)
+                            ],
+                        }
+                    ],
+                }
+            )
+        return {
             "schema": "2.0",
             "config": {
                 "update_multi": True,
                 "enable_forward": True,
-                "streaming_mode": True,
-                "summary": {"content": "Generating..."},
+                "streaming_mode": streaming,
+                "summary": {"content": "Generating..." if streaming else shorten(text, 80)},
                 "streaming_config": {
                     "print_frequency_ms": {"default": 70},
                     "print_step": {"default": 1},
                     "print_strategy": "fast",
-                },
+                } if streaming else {},
             },
             "header": {
-                "template": "orange",
+                "template": template,
                 "title": {"tag": "plain_text", "content": f"{provider_name.capitalize()} Reply"},
+                "text_tag_list": [
+                    {
+                        "tag": "text_tag",
+                        "text": {"tag": "plain_text", "content": tag_text},
+                        "color": tag_color,
+                    }
+                ],
             },
             "body": {
                 "padding": "14px",
                 "vertical_spacing": "8px",
-                "elements": [
-                    {
-                        "tag": "markdown",
-                        "element_id": element_id,
-                        "content": f"PoCo is thinking with {provider_name}...",
-                    }
-                ],
+                "elements": elements,
             },
         }
+
+    def create_streaming_answer_card(self, provider_name: str) -> Tuple[str, str]:
+        """Create a reusable streaming card entity for one answer."""
+        element_id = "answer_stream"
+        card = self.answer_card(
+            provider_name,
+            f"PoCo is thinking with {provider_name}...",
+            state="running",
+            stop_enabled=True,
+            streaming=True,
+            element_id=element_id,
+        )
         return self.app._messenger.create_card_entity(card), element_id
 
     def cleanup_session(self, session: TurnSession) -> None:

{pocket_coding-0.2.0 → pocket_coding-0.2.1}/poco/relay/stores.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import fcntl
 import json
 import logging
 import threading
@@ -13,111 +14,155 @@ LOG = logging.getLogger("poco.relay")
 
 
 class ThreadStore:
-    """Persists worker-to-thread bindings."""
+    """Persists worker-to-thread bindings with cross-process safety."""
 
     def __init__(self, path: Path) -> None:
         self._path = path
         self._lock = threading.Lock()
         self._data: Dict[str, str] = {}
-        self._load()
+        self._refresh()
 
-    def _load(self) -> None:
+    def _load_disk(self) -> Dict[str, str]:
         if not self._path.exists():
-            return
+            return {}
         try:
             raw = json.loads(self._path.read_text(encoding="utf-8"))
             if isinstance(raw, dict):
-                self._data = {str(k): str(v) for k, v in raw.items()}
+                return {str(k): str(v) for k, v in raw.items()}
         except Exception:
             LOG.warning("Failed to load thread state from %s", self._path)
+        return {}
+
+    def _refresh(self) -> None:
+        self._data = self._load_disk()
 
     def _save(self) -> None:
-        self._path.write_text(
-            json.dumps(self._data, ensure_ascii=False, indent=2),
-            encoding="utf-8",
-        )
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+        with self._path.open("a+", encoding="utf-8") as handle:
+            fcntl.flock(handle.fileno(), fcntl.LOCK_EX)
+            disk_data = self._load_disk()
+            disk_data.update(self._data)
+            self._data = disk_data
+            handle.seek(0)
+            handle.truncate()
+            handle.write(json.dumps(self._data, ensure_ascii=False, indent=2))
+            handle.flush()
+            fcntl.flock(handle.fileno(), fcntl.LOCK_UN)
 
     def get(self, chat_id: str) -> Optional[str]:
         with self._lock:
+            self._refresh()
             return self._data.get(chat_id)
 
     def set(self, chat_id: str, thread_id: str) -> None:
         with self._lock:
+            self._refresh()
             self._data[chat_id] = thread_id
             self._save()
 
     def clear(self, chat_id: str) -> None:
         with self._lock:
+            self._refresh()
             if chat_id in self._data:
                 del self._data[chat_id]
                 self._save()
 
 
 class WorkerStore:
-    """Persists per-group worker configuration."""
+    """Persists per-group worker configuration with cross-process safety."""
 
     def __init__(self, path: Path) -> None:
         self._path = path
         self._lock = threading.Lock()
         self._data: Dict[str, Dict[str, object]] = {}
-        self._load()
+        self._refresh()
 
-    def _load(self) -> None:
+    @staticmethod
+    def _normalize_payload(payload: object) -> Optional[Dict[str, object]]:
+        if not isinstance(payload, dict):
+            return None
+        alias = str(payload.get("alias", "")).strip()
+        provider = str(payload.get("provider", "")).strip().lower() or "codex"
+        backend = str(payload.get("backend", "")).strip().lower()
+        if not backend:
+            backend = "openai" if provider == "codex" else ""
+        mode = str(payload.get("mode", "auto")).strip() or "auto"
+        enabled = bool(payload.get("enabled", False))
+        cwd = str(payload.get("cwd", "")).strip()
+        model = str(payload.get("model", "")).strip()
+        return {
+            "alias": alias,
+            "provider": provider,
+            "backend": backend,
+            "mode": mode,
+            "model": model,
+            "enabled": enabled,
+            "cwd": cwd,
+        }
+
+    def _load_disk(self) -> Dict[str, Dict[str, object]]:
         if not self._path.exists():
-            return
+            return {}
         try:
             raw = json.loads(self._path.read_text(encoding="utf-8"))
             if isinstance(raw, dict):
                 cleaned: Dict[str, Dict[str, object]] = {}
                 for worker_id, payload in raw.items():
-                    if not isinstance(payload, dict):
-                        continue
-                    alias = str(payload.get("alias", "")).strip()
-                    provider = str(payload.get("provider", "")).strip().lower() or "codex"
-                    backend = str(payload.get("backend", "")).strip().lower()
-                    if not backend:
-                        backend = "openai" if provider == "codex" else ""
-                    mode = str(payload.get("mode", "auto")).strip() or "auto"
-                    enabled = bool(payload.get("enabled", False))
-                    cwd = str(payload.get("cwd", "")).strip()
-                    model = str(payload.get("model", "")).strip()
-                    cleaned[str(worker_id)] = {
-                        "alias": alias,
-                        "provider": provider,
-                        "backend": backend,
-                        "mode": mode,
-                        "model": model,
-                        "enabled": enabled,
-                        "cwd": cwd,
-                    }
-                self._data = cleaned
+                    normalized = self._normalize_payload(payload)
+                    if normalized is not None:
+                        cleaned[str(worker_id)] = normalized
+                return cleaned
         except Exception:
             LOG.warning("Failed to load worker state from %s", self._path)
+        return {}
+
+    def _refresh(self) -> None:
+        self._data = self._load_disk()
 
     def _save(self) -> None:
-        self._path.write_text(
-            json.dumps(self._data, ensure_ascii=False, indent=2),
-            encoding="utf-8",
-        )
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+        with self._path.open("a+", encoding="utf-8") as handle:
+            fcntl.flock(handle.fileno(), fcntl.LOCK_EX)
+            disk_data = self._load_disk()
+            disk_data.update(self._data)
+            self._data = disk_data
+            handle.seek(0)
+            handle.truncate()
+            handle.write(json.dumps(self._data, ensure_ascii=False, indent=2))
+            handle.flush()
+            fcntl.flock(handle.fileno(), fcntl.LOCK_UN)
+
+    def has_worker(self, worker_id: str) -> bool:
+        with self._lock:
+            self._refresh()
+            return worker_id in self._data
 
     def alias_for(self, worker_id: str) -> str:
         with self._lock:
-            payload = self._ensure_record_locked(worker_id)
+            self._refresh()
+            payload = self._data.get(worker_id) or {}
             return str(payload.get("alias", "")).strip()
 
     def provider_for(self, worker_id: str) -> str:
         with self._lock:
-            payload = self._ensure_record_locked(worker_id)
+            self._refresh()
+            payload = self._data.get(worker_id) or {}
             return str(payload.get("provider", "")).strip().lower()
 
     def backend_for(self, worker_id: str) -> str:
         with self._lock:
-            payload = self._ensure_record_locked(worker_id)
-            return str(payload.get("backend", "")).strip().lower()
+            self._refresh()
+            payload = self._data.get(worker_id) or {}
+            provider = str(payload.get("provider", "")).strip().lower()
+            backend = str(payload.get("backend", "")).strip().lower()
+            if not backend and provider == "codex":
+                return "openai"
+            return backend
 
     def set_provider(self, worker_id: str, provider: str) -> None:
         provider_value = provider.strip().lower()
         with self._lock:
+            self._refresh()
             payload = self._ensure_record_locked(worker_id)
             payload["provider"] = provider_value
             payload["backend"] = ""
@@ -127,6 +172,7 @@ class WorkerStore:
     def set_backend(self, worker_id: str, backend: str) -> None:
         backend_value = backend.strip().lower()
         with self._lock:
+            self._refresh()
             payload = self._ensure_record_locked(worker_id)
             payload["backend"] = backend_value
             payload["model"] = ""
@@ -135,6 +181,7 @@ class WorkerStore:
     def set_alias(self, worker_id: str, alias: str) -> None:
         alias = alias.strip()
         with self._lock:
+            self._refresh()
             for existing_worker_id, payload in list(self._data.items()):
                 if existing_worker_id != worker_id and payload.get("alias", "") == alias:
                     raise ValueError(f"别名 {alias} 已被 worker {existing_worker_id} 使用。")
@@ -147,6 +194,7 @@ class WorkerStore:
         if not alias_value:
             return False
         with self._lock:
+            self._refresh()
             for worker_id, payload in self._data.items():
                 if except_worker_id and worker_id == except_worker_id:
                     continue
@@ -156,55 +204,65 @@ class WorkerStore:
 
     def clear_alias(self, worker_id: str) -> None:
         with self._lock:
+            self._refresh()
             payload = self._ensure_record_locked(worker_id)
             payload["alias"] = ""
             self._save()
 
     def mode_for(self, worker_id: str) -> str:
         with self._lock:
-            payload = self._ensure_record_locked(worker_id)
+            self._refresh()
+            payload = self._data.get(worker_id) or {}
             return str(payload.get("mode", "auto")).strip() or "auto"
 
     def set_mode(self, worker_id: str, mode: str) -> None:
         with self._lock:
+            self._refresh()
             payload = self._ensure_record_locked(worker_id)
             payload["mode"] = mode
             self._save()
 
     def enabled_for(self, worker_id: str) -> bool:
         with self._lock:
-            payload = self._ensure_record_locked(worker_id)
+            self._refresh()
+            payload = self._data.get(worker_id) or {}
             return bool(payload.get("enabled", False))
 
     def set_enabled(self, worker_id: str, enabled: bool) -> None:
         with self._lock:
+            self._refresh()
             payload = self._ensure_record_locked(worker_id)
             payload["enabled"] = enabled
             self._save()
 
     def ensure_worker(self, worker_id: str) -> None:
         with self._lock:
+            self._refresh()
             self._ensure_record_locked(worker_id)
             self._save()
 
     def cwd_for(self, worker_id: str) -> str:
         with self._lock:
-            payload = self._ensure_record_locked(worker_id)
+            self._refresh()
+            payload = self._data.get(worker_id) or {}
             return str(payload.get("cwd", "")).strip()
 
     def set_cwd(self, worker_id: str, cwd: str) -> None:
         with self._lock:
+            self._refresh()
             payload = self._ensure_record_locked(worker_id)
             payload["cwd"] = cwd.strip()
             self._save()
 
     def model_for(self, worker_id: str) -> str:
         with self._lock:
-            payload = self._ensure_record_locked(worker_id)
+            self._refresh()
+            payload = self._data.get(worker_id) or {}
             return str(payload.get("model", "")).strip()
 
     def set_model(self, worker_id: str, model: str) -> None:
         with self._lock:
+            self._refresh()
             payload = self._ensure_record_locked(worker_id)
             payload["model"] = model.strip()
             self._save()
@@ -214,6 +272,7 @@ class WorkerStore:
         if not key:
             return None
         with self._lock:
+            self._refresh()
             if key in self._data:
                 return key
             for worker_id, payload in self._data.items():
@@ -223,10 +282,12 @@ class WorkerStore:
 
     def items(self) -> list[tuple[str, str]]:
         with self._lock:
+            self._refresh()
             return sorted((worker_id, payload.get("alias", "")) for worker_id, payload in self._data.items())
 
     def remove(self, worker_id: str) -> None:
         with self._lock:
+            self._refresh()
             if worker_id in self._data:
                 del self._data[worker_id]
                 self._save()

{pocket_coding-0.2.0 → pocket_coding-0.2.1}/poco/runtime.py

@@ -1,16 +1,22 @@
 import logging
+import os
 import threading
 import time
 from collections import deque
+from pathlib import Path
 from typing import Any, Dict, Optional
 
+import fcntl
+
 from .relay import AppConfig, ProviderConfig, RelayApp
 from .config import (
     INPUT_IDS,
+    STATE_DIR,
     THREAD_STATE_PATH,
     WORKER_STATE_PATH,
     ConfigStore,
     config_ready,
+    missing_required_config_paths,
     normalize_config_key,
     parse_config_value,
     set_nested,
@@ -47,6 +53,7 @@ class RelayRunner:
         self._thread: Optional[threading.Thread] = None
         self._last_error: str = ""
         self._started_at: Optional[float] = None
+        self._lock_file = None
         self._lock = threading.Lock()
 
     def status(self) -> Dict[str, Any]:
@@ -61,6 +68,11 @@ class RelayRunner:
         with self._lock:
             if self._thread is not None and self._thread.is_alive():
                 return False
+            lock_file = self._acquire_single_instance_lock()
+            if lock_file is None:
+                raise RuntimeError(
+                    "Another PoCo relay process is already running. Stop the other `poco` process first."
+                )
             self._last_error = ""
             app_config = build_app_config(config)
             thread = threading.Thread(
@@ -71,6 +83,7 @@ class RelayRunner:
             )
             self._thread = thread
             self._started_at = time.time()
+            self._lock_file = lock_file
             thread.start()
             return True
 
@@ -82,6 +95,36 @@ class RelayRunner:
             with self._lock:
                 self._last_error = str(exc)
             LOG.exception("Relay runtime crashed")
+        finally:
+            self._release_single_instance_lock()
+
+    def _acquire_single_instance_lock(self):
+        lock_path = Path(STATE_DIR) / "relay.lock"
+        handle = lock_path.open("w", encoding="utf-8")
+        try:
+            fcntl.flock(handle.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+        except BlockingIOError:
+            handle.close()
+            return None
+        handle.seek(0)
+        handle.truncate()
+        handle.write(str(os.getpid()))
+        handle.flush()
+        return handle
+
+    def _release_single_instance_lock(self) -> None:
+        with self._lock:
+            handle = self._lock_file
+            self._lock_file = None
+            self._thread = None
+            self._started_at = None
+        if handle is None:
+            return
+        try:
+            fcntl.flock(handle.fileno(), fcntl.LOCK_UN)
+        except OSError:
+            pass
+        handle.close()
 
 
 def build_app_config(config: Dict[str, Any]) -> AppConfig:
@@ -162,5 +205,6 @@ class PoCoService:
     def start_relay(self) -> bool:
         config = self.load_config()
         if not config_ready(config):
-            raise ValueError("配置还不完整，至少需要 Feishu App ID 和 App Secret。")
+            missing = ", ".join(missing_required_config_paths(config))
+            raise ValueError(f"配置还不完整，缺少：{missing}")
         return self.relay.start(config)

{pocket_coding-0.2.0 → pocket_coding-0.2.1}/poco/tui/app.py

@@ -8,7 +8,7 @@ from textual.containers import Container, Horizontal
 from textual.widgets import Input, Static
 
 from .. import __version__
-from ..config import config_ready
+from ..config import config_ready, missing_required_config_paths
 from ..providers import model_choices
 from .resources import POCO_ICON, STRINGS, TUI_CSS
 from .menus.config import (
@@ -291,6 +291,22 @@ class PoCoTui(App[None]):
             value = value.get(part, "")
         return str(value or "")
 
+    @staticmethod
+    def _missing_config_field_name(path: str) -> str:
+        """Returns a short human-readable field name for one required path."""
+        mapping = {
+            "feishu.app_id": "app_id",
+            "feishu.app_secret": "app_secret",
+        }
+        return mapping.get(path, path)
+
+    def _missing_config_fields_text(self, config: dict) -> str:
+        """Returns a compact comma-separated summary of missing required fields."""
+        return ", ".join(
+            self._missing_config_field_name(path)
+            for path in missing_required_config_paths(config)
+        )
+
     def compose(self) -> ComposeResult:
         """Builds the Textual widget tree."""
         with Horizontal(id="main_panel"):
@@ -315,7 +331,11 @@ class PoCoTui(App[None]):
         config = self._service.load_config()
         if self._focus_config or not config_ready(config):
             self._enter_config_mode()
-            self._set_message(self._t("config_required"))
+            missing = self._missing_config_fields_text(config)
+            if missing:
+                self._set_message(self._t("config_missing", fields=missing))
+            else:
+                self._set_message(self._t("config_required"))
             return
         self._service.start_relay()
         self._set_message(self._t("relay_started"), transient=True)
@@ -337,13 +357,19 @@ class PoCoTui(App[None]):
         relay_style = "#3fb950" if relay["running"] else "#f85149"
         config_status = self._t("ready") if config_ready(config) else self._t("needs_config")
         config_style = "#3fb950" if config_ready(config) else "#f2cc60"
-        return (
+        lines = [
             f"[bold #fb923c]{POCO_ICON}[/]\n"
             f"[bold #fb923c]PoCo v{__version__}[/]\n"
             "\n"
             f"{self._t('relay')}: [bold {relay_style}]{relay_status}[/]\n"
             f"{self._t('settings')}: [bold {config_style}]{config_status}[/]"
-        )
+        ]
+        if not config_ready(config):
+            missing = self._missing_config_fields_text(config)
+            if missing:
+                lines.append("")
+                lines.append(f"[bold #f2cc60]{self._t('missing_label')}[/]: [#f2cc60]{missing}[/]")
+        return "\n".join(lines)
 
     def _right_panel_text(self, config: dict, relay: dict) -> str:
         """Builds the right panel text for the current view."""

{pocket_coding-0.2.0 → pocket_coding-0.2.1}/poco/tui/resources.py

@@ -103,9 +103,14 @@ STRINGS = {
     "current_secret": {"en": "current secret", "zh": "当前密钥"},
     "empty": {"en": "empty", "zh": "空"},
     "config_required": {
-        "en": "Config is incomplete. Open Config in the menu and finish the required fields.",
-        "zh": "配置还不完整。请在菜单中打开 Config 并完成必填项。",
+        "en": "Config is incomplete. Open Bot (feishu) and finish the required fields.",
+        "zh": "配置还不完整。请打开 Bot (feishu) 并完成必填项。",
     },
+    "config_missing": {
+        "en": "Missing in Bot (feishu): {fields}",
+        "zh": "Bot (feishu) 缺少：{fields}",
+    },
+    "missing_label": {"en": "Missing", "zh": "缺少"},
     "relay_started": {"en": "PoCo relay is running.", "zh": "PoCo relay 已启动。"},
     "relay_already_running": {"en": "PoCo relay is already running.", "zh": "PoCo relay 已经在运行。"},
     "left_config": {"en": "Left config mode.", "zh": "已退出配置模式。"},

{pocket_coding-0.2.0 → pocket_coding-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pocket-coding"
-version = "0.2.0"
+version = "0.2.1"
 description = "PoCo: Pocket Coding for Feishu"
 readme = "README.md"
 requires-python = ">=3.11"