pocket-coding 0.2.2__tar.gz → 0.3.0__tar.gz

{pocket_coding-0.2.2 → pocket_coding-0.3.0}/PKG-INFO

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

{pocket_coding-0.2.2 → pocket_coding-0.3.0}/poco/__init__.py

@@ -1,4 +1,4 @@
 """PoCo package."""
 
 __all__ = ["__version__"]
-__version__ = "0.2.2"
+__version__ = "0.3.0"

pocket_coding-0.3.0/poco/app.py

@@ -0,0 +1,124 @@
+#!/usr/bin/env python3
+import argparse
+import json
+import logging
+import os
+import sys
+from logging.handlers import RotatingFileHandler
+from pathlib import Path
+from .runtime import (
+    PoCoService,
+    RingLogHandler,
+)
+from .config import ConfigStore, bind_workspace, build_paths, ensure_dirs, get_nested, workspace_binding
+from .tui import PoCoTui
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="PoCo")
+    parser.add_argument("--log-level", default="INFO")
+    sub = parser.add_subparsers(dest="command")
+    config_cmd = sub.add_parser("config", help="open PoCo and focus config tab")
+    config_cmd.add_argument("--show", action="store_true", help="show masked config and exit")
+    config_cmd.add_argument("key", nargs="?", help="config key, e.g. app_id or feishu.app_id")
+    config_cmd.add_argument("value", nargs="?", help="config value")
+    return parser.parse_args()
+
+
+def _env_flag(name: str) -> bool:
+    value = os.getenv(name, "").strip().lower()
+    return value in {"1", "true", "yes", "on"}
+
+
+def _env_feishu_binding() -> tuple[str, str, str] | None:
+    if not _env_flag("POCO_BIND_SKIP"):
+        return None
+    app_id = os.getenv("POCO_FEISHU_APP_ID", "").strip()
+    app_secret = os.getenv("POCO_FEISHU_APP_SECRET", "").strip()
+    if not app_id or not app_secret:
+        return None
+    alias = os.getenv("POCO_FEISHU_ALIAS", "").strip()
+    return app_id, app_secret, alias
+
+
+def _apply_env_binding(workspace: Path, app_id: str, app_secret: str, alias: str) -> str:
+    bind_workspace(workspace, app_id)
+    paths = build_paths(app_id)
+    ensure_dirs(paths)
+    store = ConfigStore(paths.config_path, paths)
+    config = store.load()
+    feishu = config.setdefault("feishu", {})
+    feishu["app_id"] = app_id
+    feishu["app_secret"] = app_secret
+    if alias:
+        feishu["alias"] = alias
+    store.save(config)
+    return app_id
+
+
+def main() -> None:
+    args = parse_args()
+    workspace = Path.cwd()
+    env_binding = _env_feishu_binding()
+    binding = workspace_binding(workspace)
+    if env_binding is not None:
+        binding = _apply_env_binding(workspace, *env_binding)
+    root_logger = logging.getLogger()
+    root_logger.setLevel(getattr(logging, str(getattr(args, "log_level", "INFO")).upper(), logging.INFO))
+    for handler in list(root_logger.handlers):
+        if isinstance(handler, logging.StreamHandler) and not isinstance(handler, logging.FileHandler):
+            root_logger.removeHandler(handler)
+    ring = RingLogHandler()
+    ring.setFormatter(logging.Formatter("%(asctime)s %(levelname)s %(name)s: %(message)s"))
+    root_logger.addHandler(ring)
+    file_handler: RotatingFileHandler | None = None
+
+    def build_service_for(app_id: str | None) -> PoCoService:
+        nonlocal file_handler
+        paths = build_paths(app_id or "default")
+        ensure_dirs(paths)
+        if file_handler is not None:
+            root_logger.removeHandler(file_handler)
+            file_handler.close()
+        file_handler = RotatingFileHandler(
+            paths.log_path,
+            maxBytes=2_000_000,
+            backupCount=3,
+            encoding="utf-8",
+            mode="w",
+        )
+        file_handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)s %(name)s: %(message)s"))
+        root_logger.addHandler(file_handler)
+        logging.getLogger("poco").info(
+            "Persistent log file enabled at %s (instance=%s)",
+            paths.log_path,
+            app_id or "default",
+        )
+        store = ConfigStore(paths.config_path, paths)
+        return PoCoService(store, ring, paths)
+
+    service = build_service_for(binding)
+
+    if args.command == "config" and args.show:
+        print(json.dumps(service.masked_config(), ensure_ascii=False, indent=2))
+        return
+    if args.command == "config" and args.key:
+        if args.value is None:
+            raise SystemExit("usage: poco config <key> <value>")
+        path, _ = service.set_config_value(args.key, args.value)
+        current = get_nested(service.masked_config(), path)
+        print(json.dumps({path: current}, ensure_ascii=False, indent=2))
+        return
+    app = PoCoTui(
+        service,
+        service_factory=build_service_for,
+        focus_config=args.command == "config",
+        skip_bind_on_boot=env_binding is not None,
+    )
+    result = app.run()
+    if result == "restart":
+        os.execv(sys.executable, [sys.executable, *sys.argv])
+
+
+if __name__ == "__main__":
+    main()

{pocket_coding-0.2.2 → pocket_coding-0.3.0}/poco/config/__init__.py

@@ -1,5 +1,6 @@
 from .store import (
     PoCoPaths,
+    SavedFeishuBot,
     WORKSPACE_BINDINGS_PATH,
     CONFIG_KEY_ALIASES,
     CONFIG_PATH,
@@ -22,12 +23,14 @@ from .store import (
     normalize_config_key,
     parse_config_value,
     saved_feishu_bot_ids,
+    saved_feishu_bots,
     set_nested,
     workspace_binding,
 )
 
 __all__ = [
     "PoCoPaths",
+    "SavedFeishuBot",
     "WORKSPACE_BINDINGS_PATH",
     "CONFIG_KEY_ALIASES",
     "CONFIG_PATH",
@@ -50,6 +53,7 @@ __all__ = [
     "normalize_config_key",
     "parse_config_value",
     "saved_feishu_bot_ids",
+    "saved_feishu_bots",
     "set_nested",
     "workspace_binding",
 ]

{pocket_coding-0.2.2 → pocket_coding-0.3.0}/poco/config/store.py

@@ -27,6 +27,13 @@ class PoCoPaths:
     relay_lock_path: Path
 
 
+@dataclass(frozen=True)
+class SavedFeishuBot:
+    app_id: str
+    app_name: str = ""
+    alias: str = ""
+
+
 def normalize_instance_name(instance: str) -> str:
     value = (instance or "").strip()
     if not value:
@@ -65,6 +72,8 @@ LOG_PATH = _DEFAULT_PATHS.log_path
 
 DEFAULT_CONFIG: Dict[str, Any] = {
     "feishu": {
+        "alias": "",
+        "app_name": "",
         "app_id": "",
         "app_secret": "",
         "encrypt_key": "",
@@ -81,6 +90,13 @@ DEFAULT_CONFIG: Dict[str, Any] = {
         "approval_policy": "never",
         "sandbox": "danger-full-access",
     },
+    "cursor": {
+        "bin": "cursor-agent",
+        "app_server_args": "",
+        "model": "auto",
+        "approval_policy": "force",
+        "sandbox": "disabled",
+    },
     "claude": {
         "bin": "claude",
         "app_server_args": "",
@@ -129,6 +145,7 @@ DEFAULT_CONFIG: Dict[str, Any] = {
 }
 
 INPUT_IDS = {
+    "feishu.alias": "feishu_alias",
     "feishu.app_id": "feishu_app_id",
     "feishu.app_secret": "feishu_app_secret",
     "feishu.encrypt_key": "feishu_encrypt_key",
@@ -141,6 +158,11 @@ INPUT_IDS = {
     "codex.reasoning_effort": "codex_reasoning_effort",
     "codex.approval_policy": "codex_approval_policy",
     "codex.sandbox": "codex_sandbox",
+    "cursor.bin": "cursor_bin",
+    "cursor.app_server_args": "cursor_app_server_args",
+    "cursor.model": "cursor_model",
+    "cursor.approval_policy": "cursor_approval_policy",
+    "cursor.sandbox": "cursor_sandbox",
     "claude.bin": "claude_bin",
     "claude.app_server_args": "claude_app_server_args",
     "claude.approval_policy": "claude_approval_policy",
@@ -162,6 +184,7 @@ INPUT_IDS = {
 }
 
 CONFIG_KEY_ALIASES = {
+    "alias": "feishu.alias",
     "app_id": "feishu.app_id",
     "app_secret": "feishu.app_secret",
     "encrypt_key": "feishu.encrypt_key",
@@ -175,6 +198,11 @@ CONFIG_KEY_ALIASES = {
     "reasoning_effort": "codex.reasoning_effort",
     "approval_policy": "codex.approval_policy",
     "sandbox": "codex.sandbox",
+    "cursor_bin": "cursor.bin",
+    "cursor_app_server_args": "cursor.app_server_args",
+    "cursor_model": "cursor.model",
+    "cursor_approval_policy": "cursor.approval_policy",
+    "cursor_sandbox": "cursor.sandbox",
     "claude_bin": "claude.bin",
     "claude_app_server_args": "claude.app_server_args",
     "claude_approval_policy": "claude.approval_policy",
@@ -210,12 +238,24 @@ def normalize_config(config: Dict[str, Any]) -> Dict[str, Any]:
     Returns:
         The normalized config dictionary.
     """
+    feishu = config.setdefault("feishu", {})
+    feishu.setdefault("alias", "")
+    feishu.setdefault("app_name", "")
+
     codex = config.setdefault("codex", {})
     if not str(codex.get("model", "")).strip():
         codex["model"] = DEFAULT_CONFIG["codex"]["model"]
     if not str(codex.get("reasoning_effort", "")).strip():
         codex["reasoning_effort"] = DEFAULT_CONFIG["codex"]["reasoning_effort"]
 
+    cursor = config.setdefault("cursor", {})
+    if not str(cursor.get("model", "")).strip():
+        cursor["model"] = DEFAULT_CONFIG["cursor"]["model"]
+    if not str(cursor.get("approval_policy", "")).strip():
+        cursor["approval_policy"] = DEFAULT_CONFIG["cursor"]["approval_policy"]
+    if not str(cursor.get("sandbox", "")).strip():
+        cursor["sandbox"] = DEFAULT_CONFIG["cursor"]["sandbox"]
+
     claude = config.setdefault("claude", {})
     if not str(claude.get("default_backend", "")).strip():
         claude["default_backend"] = DEFAULT_CONFIG["claude"]["default_backend"]
@@ -337,6 +377,40 @@ def saved_feishu_bot_ids() -> list[str]:
     return sorted(bot_ids)
 
 
+def saved_feishu_bots() -> list[SavedFeishuBot]:
+    """Returns saved Feishu bots with local alias and app name when available."""
+    bots: dict[str, SavedFeishuBot] = {}
+
+    def collect_from_config(path: Path, paths: PoCoPaths) -> None:
+        try:
+            config = ConfigStore(path, paths).load()
+        except Exception:
+            LOG.exception("Failed to load saved bot config from %s", path)
+            return
+        if not config_ready(config):
+            return
+        feishu = config.get("feishu", {})
+        app_id = str(feishu.get("app_id", "")).strip()
+        if not app_id:
+            return
+        bots[app_id] = SavedFeishuBot(
+            app_id=app_id,
+            app_name=str(feishu.get("app_name", "")).strip(),
+            alias=str(feishu.get("alias", "")).strip(),
+        )
+
+    if CONFIG_PATH.exists():
+        collect_from_config(CONFIG_PATH, _DEFAULT_PATHS)
+
+    bindings_root = CONFIG_ROOT / "bindings"
+    if bindings_root.exists():
+        for config_path in bindings_root.glob("*/config.json"):
+            instance = config_path.parent.name
+            collect_from_config(config_path, build_paths(instance))
+
+    return sorted(bots.values(), key=lambda item: (item.alias or item.app_name or item.app_id).lower())
+
+
 def set_nested(config: Dict[str, Any], path: str, value: Any) -> Dict[str, Any]:
     parts = path.split(".")
     current = config

{pocket_coding-0.2.2 → pocket_coding-0.3.0}/poco/providers/__init__.py

@@ -7,6 +7,7 @@ from .base import (
 )
 from .claude import ClaudeProviderClient, ClaudeSessionLocator
 from .codex import CodexProviderClient, CodexSessionLocator
+from .cursor import CursorProviderClient, CursorSessionLocator
 from .models import model_choices
 
 
@@ -16,6 +17,8 @@ def build_provider_client(provider_name: str, provider_config: ProviderConfig, c
         return CodexProviderClient(provider_config, cwd)
     if provider == "claude":
         return ClaudeProviderClient(provider_config, cwd)
+    if provider == "cursor":
+        return CursorProviderClient(provider_config, cwd)
     raise RuntimeError(f"Unsupported provider: {provider_name}")
 
 
@@ -23,6 +26,7 @@ def build_session_locators() -> dict[str, SessionLocator]:
     return {
         "codex": CodexSessionLocator(),
         "claude": ClaudeSessionLocator(),
+        "cursor": CursorSessionLocator(),
     }
 
 
@@ -31,6 +35,8 @@ __all__ = [
     "ClaudeSessionLocator",
     "CodexProviderClient",
     "CodexSessionLocator",
+    "CursorProviderClient",
+    "CursorSessionLocator",
     "build_provider_client",
     "build_session_locators",
     "model_choices",

{pocket_coding-0.2.2 → pocket_coding-0.3.0}/poco/providers/codex.py

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