openab 0.3.0__py3-none-any.whl

openab/__init__.py

@@ -0,0 +1,2 @@
+# OpenAB — Open Agent Bridge
+__version__ = "0.2.0"

openab/__main__.py

@@ -0,0 +1,5 @@
+"""Entry point: python -m openab"""
+from openab.cli.main import app
+
+if __name__ == "__main__":
+    app()

openab/agents/__init__.py

@@ -0,0 +1,71 @@
+"""Agent backends: Cursor, Codex, Gemini, Claude, OpenClaw. 由 agent_config 或环境变量指定后端与选项。"""
+from __future__ import annotations
+
+import asyncio
+import os
+from pathlib import Path
+from typing import Any, Optional
+
+from openab.core.i18n import t
+
+from . import claude, codex, cursor, gemini, openclaw
+
+
+def get_backend(agent_config: dict[str, Any] | None = None) -> str:
+    if agent_config:
+        agent = agent_config.get("agent") or {}
+        b = agent.get("backend") or "cursor"
+        return str(b).strip().lower()
+    return (os.environ.get("OPENAB_AGENT") or "cursor").strip().lower()
+
+
+def run_agent(
+    prompt: str,
+    *,
+    workspace: Optional[Path] = None,
+    timeout: Optional[int] = None,
+    agent_config: Optional[dict[str, Any]] = None,
+) -> str:
+    """同步执行当前配置的 agent，返回完整 stdout 文本。"""
+    return asyncio.get_event_loop().run_until_complete(
+        run_agent_async(
+            prompt,
+            workspace=workspace,
+            timeout=timeout,
+            agent_config=agent_config,
+        )
+    )
+
+
+async def run_agent_async(
+    prompt: str,
+    *,
+    workspace: Optional[Path] = None,
+    timeout: int = 300,
+    lang: str = "en",
+    agent_config: Optional[dict[str, Any]] = None,
+) -> str:
+    """异步执行 agent；backend 与各后端选项来自 agent_config，缺省时回退到环境变量。"""
+    backend = get_backend(agent_config)
+    if backend == "codex":
+        return await codex.run_async(
+            prompt, workspace=workspace, timeout=timeout, lang=lang, agent_config=agent_config
+        )
+    if backend == "gemini":
+        return await gemini.run_async(
+            prompt, workspace=workspace, timeout=timeout, lang=lang, agent_config=agent_config
+        )
+    if backend == "claude":
+        return await claude.run_async(
+            prompt, workspace=workspace, timeout=timeout, lang=lang, agent_config=agent_config
+        )
+    if backend == "openclaw":
+        return await openclaw.run_async(
+            prompt, workspace=workspace, timeout=timeout, lang=lang, agent_config=agent_config
+        )
+    return await cursor.run_async(
+        prompt, workspace=workspace, timeout=timeout, lang=lang, agent_config=agent_config
+    )
+
+
+__all__ = ["run_agent", "run_agent_async", "get_backend"]

openab/agents/claude.py

@@ -0,0 +1,100 @@
+"""Claude Code CLI backend (https://code.claude.com/docs/en/cli-reference).
+
+Print mode: claude -p "query" — response to stdout, then exit.
+Flags used: --output-format text, --no-session-persistence; optional: --model, --max-turns, --add-dir.
+"""
+from __future__ import annotations
+
+import asyncio
+import os
+import shutil
+from pathlib import Path
+from typing import Any, Optional
+
+from openab.core.i18n import t
+
+
+def _find_cmd(agent_config: dict[str, Any] | None = None) -> str:
+    cmd = "claude"
+    if agent_config:
+        c = (agent_config.get("claude") or {}).get("cmd")
+        if c:
+            cmd = str(c)
+    if not cmd:
+        cmd = os.environ.get("CLAUDE_CLI_CMD", "claude")
+    if os.path.isabs(cmd):
+        return cmd
+    exe = shutil.which(cmd)
+    return exe or cmd
+
+
+def _build_args(
+    prompt: str,
+    workspace: Optional[Path],
+    agent_config: dict[str, Any] | None = None,
+) -> list[str]:
+    cmd = _find_cmd(agent_config)
+    args = [
+        cmd,
+        "--print",
+        "--output-format", "text",
+        "--no-session-persistence",
+    ]
+    model = ""
+    max_turns = ""
+    add_dirs: list[str] = []
+    if agent_config:
+        c = agent_config.get("claude") or {}
+        if c.get("model"):
+            model = str(c["model"]).strip()
+        if c.get("max_turns") is not None:
+            max_turns = str(c["max_turns"]).strip()
+        ad = c.get("add_dir")
+        if isinstance(ad, str) and ad:
+            add_dirs = [d.strip() for d in ad.split(os.pathsep) if d.strip()]
+        elif isinstance(ad, list):
+            add_dirs = [str(x).strip() for x in ad if str(x).strip()]
+    if not model:
+        model = os.environ.get("CLAUDE_CLI_MODEL", "").strip()
+    if not max_turns:
+        max_turns = os.environ.get("CLAUDE_CLI_MAX_TURNS", "").strip()
+    if not add_dirs:
+        raw = os.environ.get("CLAUDE_CLI_ADD_DIR", "").strip()
+        if raw:
+            add_dirs = [d.strip() for d in raw.split(os.pathsep) if d.strip()]
+    if model:
+        args.extend(["--model", model])
+    if max_turns and max_turns.isdigit():
+        args.extend(["--max-turns", max_turns])
+    for d in add_dirs:
+        args.extend(["--add-dir", d])
+    args.append(prompt)
+    return args
+
+
+async def run_async(
+    prompt: str,
+    *,
+    workspace: Optional[Path] = None,
+    timeout: int = 300,
+    lang: str = "en",
+    agent_config: Optional[dict[str, Any]] = None,
+) -> str:
+    """Run Claude Code CLI in print mode; return stdout as reply."""
+    args = _build_args(prompt, workspace, agent_config)
+    cwd = str(workspace) if workspace else None
+    proc = await asyncio.create_subprocess_exec(
+        *args,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+        env=os.environ.copy(),
+        cwd=cwd,
+    )
+    try:
+        stdout, _ = await asyncio.wait_for(proc.communicate(), timeout=timeout)
+    except asyncio.TimeoutError:
+        proc.kill()
+        await proc.wait()
+        return t(lang, "agent_timeout")
+    text = (stdout or b"").decode("utf-8", errors="replace").strip()
+    return text or t(lang, "agent_no_output")

openab/agents/codex.py

@@ -0,0 +1,64 @@
+"""OpenAI Codex CLI backend."""
+from __future__ import annotations
+
+import asyncio
+import os
+import shutil
+from pathlib import Path
+from typing import Any, Optional
+
+from openab.core.i18n import t
+
+
+def _find_cmd(agent_config: dict[str, Any] | None = None) -> str:
+    cmd = "codex"
+    if agent_config:
+        c = (agent_config.get("codex") or {}).get("cmd")
+        if c:
+            cmd = str(c)
+    if not cmd:
+        cmd = os.environ.get("CODEX_CMD", "codex")
+    if os.path.isabs(cmd):
+        return cmd
+    exe = shutil.which(cmd)
+    return exe or cmd
+
+
+def _skip_git_check(agent_config: dict[str, Any] | None = None) -> bool:
+    if agent_config:
+        v = (agent_config.get("codex") or {}).get("skip_git_check")
+        if v in (True, "true", "1", 1):
+            return True
+    return os.environ.get("CODEX_SKIP_GIT_CHECK", "").strip().lower() in ("1", "true", "yes")
+
+
+async def run_async(
+    prompt: str,
+    *,
+    workspace: Optional[Path] = None,
+    timeout: int = 300,
+    lang: str = "en",
+    agent_config: Optional[dict[str, Any]] = None,
+) -> str:
+    """Codex CLI: codex exec --ephemeral, final message on stdout."""
+    cmd = _find_cmd(agent_config)
+    args = [cmd, "exec", "--ephemeral"]
+    if _skip_git_check(agent_config):
+        args.append("--skip-git-repo-check")
+    args.append(prompt)
+    cwd = str(workspace) if workspace else None
+    proc = await asyncio.create_subprocess_exec(
+        *args,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.DEVNULL,
+        env=os.environ.copy(),
+        cwd=cwd,
+    )
+    try:
+        stdout, _ = await asyncio.wait_for(proc.communicate(), timeout=timeout)
+    except asyncio.TimeoutError:
+        proc.kill()
+        await proc.wait()
+        return t(lang, "agent_timeout")
+    text = (stdout or b"").decode("utf-8", errors="replace").strip()
+    return text or t(lang, "agent_no_output")

openab/agents/cursor.py

@@ -0,0 +1,62 @@
+"""Cursor Agent CLI backend."""
+from __future__ import annotations
+
+import asyncio
+import os
+import shutil
+from pathlib import Path
+from typing import Any, Optional
+
+from openab.core.i18n import t
+
+
+def _find_cmd(agent_config: dict[str, Any] | None = None) -> str:
+    cmd = "agent"
+    if agent_config:
+        c = (agent_config.get("cursor") or {}).get("cmd")
+        if c:
+            cmd = str(c)
+    if not cmd:
+        cmd = os.environ.get("CURSOR_AGENT_CMD", "agent")
+    if os.path.isabs(cmd):
+        return cmd
+    exe = shutil.which(cmd)
+    return exe or cmd
+
+
+async def run_async(
+    prompt: str,
+    *,
+    workspace: Optional[Path] = None,
+    timeout: int = 300,
+    lang: str = "en",
+    agent_config: Optional[dict[str, Any]] = None,
+) -> str:
+    """Cursor Agent CLI: agent --print --trust."""
+    cmd = _find_cmd(agent_config)
+    base_args = [
+        cmd,
+        "agent",
+        "--print",
+        "--output-format", "text",
+        "--trust",
+    ]
+    if workspace is not None:
+        base_args.extend(["--workspace", str(workspace)])
+    base_args.extend(["--", prompt])
+    env = os.environ.copy()
+    proc = await asyncio.create_subprocess_exec(
+        *base_args,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.STDOUT,
+        env=env,
+        cwd=str(workspace) if workspace else None,
+    )
+    try:
+        stdout, _ = await asyncio.wait_for(proc.communicate(), timeout=timeout)
+    except asyncio.TimeoutError:
+        proc.kill()
+        await proc.wait()
+        return t(lang, "agent_timeout")
+    text = (stdout or b"").decode("utf-8", errors="replace").strip()
+    return text or t(lang, "agent_no_output")

openab/agents/gemini.py

@@ -0,0 +1,53 @@
+"""Gemini CLI backend (google-gemini/gemini-cli)."""
+from __future__ import annotations
+
+import asyncio
+import os
+import shutil
+from pathlib import Path
+from typing import Any, Optional
+
+from openab.core.i18n import t
+
+
+def _find_cmd(agent_config: dict[str, Any] | None = None) -> str:
+    cmd = "gemini"
+    if agent_config:
+        c = (agent_config.get("gemini") or {}).get("cmd")
+        if c:
+            cmd = str(c)
+    if not cmd:
+        cmd = os.environ.get("GEMINI_CLI_CMD", "gemini")
+    if os.path.isabs(cmd):
+        return cmd
+    exe = shutil.which(cmd)
+    return exe or cmd
+
+
+async def run_async(
+    prompt: str,
+    *,
+    workspace: Optional[Path] = None,
+    timeout: int = 300,
+    lang: str = "en",
+    agent_config: Optional[dict[str, Any]] = None,
+) -> str:
+    """Gemini CLI: gemini -p \"prompt\" → stdout."""
+    cmd = _find_cmd(agent_config)
+    args = [cmd, "-p", prompt]
+    cwd = str(workspace) if workspace else None
+    proc = await asyncio.create_subprocess_exec(
+        *args,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+        env=os.environ.copy(),
+        cwd=cwd,
+    )
+    try:
+        stdout, _ = await asyncio.wait_for(proc.communicate(), timeout=timeout)
+    except asyncio.TimeoutError:
+        proc.kill()
+        await proc.wait()
+        return t(lang, "agent_timeout")
+    text = (stdout or b"").decode("utf-8", errors="replace").strip()
+    return text or t(lang, "agent_no_output")

openab/agents/openclaw.py

@@ -0,0 +1,77 @@
+"""OpenClaw 后端：通过 CLI `openclaw agent --message "..."` 调用，需先运行 OpenClaw Gateway（或使用本地回退）。
+
+参考：https://docs.openclaw.ai/tools/agent-send
+安装：npm install -g openclaw@latest，并运行 openclaw onboard / openclaw gateway。
+"""
+from __future__ import annotations
+
+import asyncio
+import os
+import shutil
+from pathlib import Path
+from typing import Any, Optional
+
+from openab.core.i18n import t
+
+
+def _find_cmd(agent_config: dict[str, Any] | None = None) -> str:
+    cmd = "openclaw"
+    if agent_config:
+        c = (agent_config.get("openclaw") or {}).get("cmd")
+        if c:
+            cmd = str(c)
+    if not cmd:
+        cmd = os.environ.get("OPENCLAW_CMD", "openclaw")
+    if os.path.isabs(cmd):
+        return cmd
+    exe = shutil.which(cmd)
+    return exe or cmd
+
+
+def _strip_media_lines(text: str) -> str:
+    """去掉 OpenClaw 输出中的 MEDIA: 行，只保留回复正文。"""
+    lines = []
+    for line in text.splitlines():
+        if line.strip().startswith("MEDIA:"):
+            continue
+        lines.append(line)
+    return "\n".join(lines).strip()
+
+
+async def run_async(
+    prompt: str,
+    *,
+    workspace: Optional[Path] = None,
+    timeout: int = 300,
+    lang: str = "en",
+    agent_config: Optional[dict[str, Any]] = None,
+) -> str:
+    """调用 openclaw agent --message \"<prompt>\"，从 stdout 取回复；默认会过滤 MEDIA: 行。"""
+    cmd = _find_cmd(agent_config)
+    args = [cmd, "agent", "--message", prompt]
+    oc_cfg = (agent_config or {}).get("openclaw") or {}
+    to = oc_cfg.get("timeout") or timeout
+    if to and int(to) > 0:
+        args.extend(["--timeout", str(int(to))])
+    thinking = (oc_cfg.get("thinking") or "").strip().lower()
+    if thinking in ("off", "minimal", "low", "medium", "high", "xhigh"):
+        args.extend(["--thinking", thinking])
+    cwd = str(workspace) if workspace else None
+    proc = await asyncio.create_subprocess_exec(
+        *args,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+        env=os.environ.copy(),
+        cwd=cwd,
+    )
+    try:
+        stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=timeout)
+    except asyncio.TimeoutError:
+        proc.kill()
+        await proc.wait()
+        return t(lang, "agent_timeout")
+    text = (stdout or b"").decode("utf-8", errors="replace")
+    text = _strip_media_lines(text)
+    if not text.strip():
+        return t(lang, "agent_no_output")
+    return text

openab/chats/__init__.py

@@ -0,0 +1 @@
+# Chat frontends: Telegram, (future: Discord, Slack, …)

openab/chats/discord/__init__.py

@@ -0,0 +1,3 @@
+from .bot import run_bot
+
+__all__ = ["run_bot"]

openab/chats/discord/bot.py

@@ -0,0 +1,167 @@
+"""Discord bot: receive messages → call agent → reply (chunked). 配置通过参数传入，不读环境变量。"""
+from __future__ import annotations
+
+import asyncio
+import logging
+from pathlib import Path
+from typing import Any, Optional
+
+import discord
+from discord import Intents
+
+from openab.agents import run_agent_async
+from openab.core.i18n import t
+
+logger = logging.getLogger(__name__)
+
+MAX_MESSAGE_LENGTH = 2000
+PREFIX = "!"
+
+
+def _split_message(text: str, max_len: int = MAX_MESSAGE_LENGTH) -> list[str]:
+    chunks = []
+    while text:
+        if len(text) <= max_len:
+            chunks.append(text)
+            break
+        cut = text.rfind("\n", 0, max_len + 1)
+        if cut <= 0:
+            cut = text.rfind(" ", 0, max_len + 1)
+        if cut <= 0:
+            cut = max_len
+        chunks.append(text[:cut].rstrip())
+        text = text[cut:].lstrip()
+    return chunks
+
+
+def _user_lang(_message: discord.Message) -> str:
+    return "en"
+
+
+async def _typing_until_done(channel: discord.abc.Messageable, done: asyncio.Event) -> None:
+    while not done.is_set():
+        try:
+            async with channel.typing():
+                await asyncio.wait_for(done.wait(), timeout=4.0)
+        except (asyncio.TimeoutError, discord.DiscordException):
+            continue
+
+
+class OpenABDiscordBot(discord.Client):
+    def __init__(
+        self,
+        *,
+        intents: Intents,
+        allowed_user_ids: frozenset[int],
+        workspace: Path,
+        timeout: int = 300,
+        agent_config: Optional[dict[str, Any]] = None,
+    ) -> None:
+        super().__init__(intents=intents)
+        self._openab_allowed = allowed_user_ids
+        self._openab_workspace = workspace
+        self._openab_timeout = timeout
+        self._openab_agent_config = agent_config or {}
+
+    def _is_user_allowed(self, user_id: int) -> bool:
+        return user_id in self._openab_allowed
+
+    def _is_auth_enabled(self) -> bool:
+        return len(self._openab_allowed) > 0
+
+    async def handle_command_start(self, message: discord.Message) -> None:
+        lang = _user_lang(message)
+        user_id = message.author.id
+        if self._is_user_allowed(user_id):
+            msg = t(lang, "start_welcome")
+        else:
+            key = "auth_not_configured" if not self._is_auth_enabled() else "unauthorized"
+            msg = t(lang, key) + "\n\n" + t(lang, "your_user_id") + str(user_id)
+        await message.reply(msg)
+
+    async def handle_command_whoami(self, message: discord.Message) -> None:
+        lang = _user_lang(message)
+        user_id = message.author.id
+        name = message.author.display_name or str(message.author)
+        status = t(lang, "status_authorized") if self._is_user_allowed(user_id) else t(lang, "status_unauthorized")
+        msg = (
+            f"{t(lang, 'whoami_id')}{user_id}\n"
+            f"{t(lang, 'whoami_username')}{name}\n"
+            f"{t(lang, 'whoami_status')}{status}"
+        )
+        await message.reply(msg)
+
+    async def handle_agent_message(self, message: discord.Message) -> None:
+        user_id = message.author.id
+        lang = _user_lang(message)
+        if not self._is_user_allowed(user_id):
+            key = "auth_not_configured" if not self._is_auth_enabled() else "unauthorized"
+            msg = t(lang, key) + "\n\n" + t(lang, "your_user_id") + str(user_id)
+            await message.reply(msg)
+            return
+
+        prompt = (message.content or "").strip()
+        if not prompt:
+            await message.reply(t(lang, "prompt_empty"))
+            return
+
+        done = asyncio.Event()
+        typing_task = asyncio.create_task(_typing_until_done(message.channel, done))
+
+        try:
+            reply = await run_agent_async(
+                prompt,
+                workspace=self._openab_workspace,
+                timeout=self._openab_timeout,
+                lang=lang,
+                agent_config=self._openab_agent_config,
+            )
+        except Exception as e:
+            logger.exception("agent run error")
+            reply = t(lang, "agent_error", error=str(e))
+        finally:
+            done.set()
+            typing_task.cancel()
+            try:
+                await typing_task
+            except asyncio.CancelledError:
+                pass
+
+        for chunk in _split_message(reply):
+            await message.reply(chunk)
+
+    async def on_ready(self) -> None:
+        logger.info("Discord bot logged in as %s", self.user)
+
+    async def on_message(self, message: discord.Message) -> None:
+        if message.author.bot:
+            return
+        content = (message.content or "").strip()
+        if content == f"{PREFIX}start":
+            await self.handle_command_start(message)
+            return
+        if content == f"{PREFIX}whoami":
+            await self.handle_command_whoami(message)
+            return
+        await self.handle_agent_message(message)
+
+
+def run_bot(
+    token: str,
+    *,
+    workspace: Path,
+    timeout: int = 300,
+    allowed_user_ids: Optional[frozenset[int]] = None,
+    agent_config: Optional[dict[str, Any]] = None,
+) -> None:
+    ids = allowed_user_ids or frozenset()
+    intents = Intents.default()
+    intents.message_content = True
+    client = OpenABDiscordBot(
+        intents=intents,
+        allowed_user_ids=ids,
+        workspace=workspace,
+        timeout=timeout,
+        agent_config=agent_config,
+    )
+    client.run(token)

openab/chats/telegram/__init__.py

@@ -0,0 +1,3 @@
+from .bot import build_application, run_bot
+
+__all__ = ["build_application", "run_bot"]