arkclaw-webchat-cli 0.6.0__tar.gz → 0.6.2__tar.gz

{arkclaw_webchat_cli-0.6.0 → arkclaw_webchat_cli-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arkclaw-webchat-cli
-Version: 0.6.0
+Version: 0.6.2
 Summary: CLI to chat with an ArkClaw EE space's Claw over enterprise SSO — zero permanent AK/SK.
 Author: ArkClaw Team
 Keywords: arkclaw,cli,ee,openclaw,sso,sts
@@ -31,7 +31,7 @@ at a prompt and for another agent/script (`--json` + exit codes).
 ```bash
 arkclaw init        # one-time interactive setup (asks only what it can't auto-detect)
 arkclaw login       # browser SSO
-arkclaw agents      # list the claws you can chat
+arkclaw agents      # list the agents you can chat
 arkclaw chat ci-xxxxxxxx
 ```
 
@@ -40,7 +40,8 @@ arkclaw chat ci-xxxxxxxx
 ## What it can do
 
 - **Log in as you** — browser SSO (PKCE), short-lived token, auto-refresh. No AK/SK, no client secret, nothing permanent on disk but a token in your OS keychain.
-- **List your agents** — `arkclaw agents` shows the claws you've chatted with (kept locally; add one with `arkclaw chat ci-...`).
+- **List your agents** — `arkclaw agents` shows the agents in your accessible claws (add a claw by chatting it once: `arkclaw chat ci-...`).
+- **Manage agents** — `agents create` / `agents delete` add or remove named agents in a claw, right from the terminal.
 - **Chat** — interactive REPL or one-shot `-m`, streaming token-by-token, with a live "what's it doing" spinner and tool-event trace.
 - **Talk to a specific claw** — by id (`chat ci-...`) or by name (`chat 答疑助手`).
 - **Manage a claw's files** — read/write its managed workspace files (`AGENTS.md`, `SOUL.md`, `MEMORY.md`, …) with `ls` / `pull` / `push`.
@@ -99,14 +100,16 @@ straight to `arkclaw login https://your-space...`. See **[Configuration](#config
 |---|---|
 | `arkclaw init [address]` | One-time interactive setup. Saves the address + (only what isn't auto-discovered) the CLI client and STS role to `~/.arkclaw/defaults.json`, so later commands need no env/flags. |
 | `arkclaw login [space-url]` | Browser SSO login. Uses `init` defaults if you omit the URL. `--transport a2a --endpoint <url>` for an agent endpoint. `--clawid ci-...` sets a default claw. Bare `arkclaw login` re-logs into the previous space. |
-| `arkclaw agents` | List the claws you've used from this machine (local history, newest first) + your default claw. Add a claw by chatting it once (`arkclaw chat ci-...`). Not a space-wide directory. |
+| `arkclaw agents` | List the agents in your accessible claws (verified over the ws; inaccessible claws are pruned). Candidate claws = the ones you've used from this machine + your default — add one by chatting it once (`arkclaw chat ci-...`). Not a space-wide directory. |
+| `arkclaw agents create` | Create a named agent in a claw: `--name` `--role` `--soul` (+ optional `--description`, repeatable `--skill`). Then `chat <claw> --agent <agentId>`. |
+| `arkclaw agents delete <agent>` | Delete a named agent by agentId (`a-...`) or display name. Asks for confirmation unless `--yes`; the `main` agent is protected. |
 | `arkclaw chat [TARGET] [MSG]` | Chat. `TARGET` = a claw id (`ci-...`), an agent name (from `agents`), or a profile. With `MSG` → one-shot; without → interactive REPL. `-f` attach files, `-o` write the reply, `--session NAME` name the conversation, `--approve-all` auto-approve tool runs. |
 | `arkclaw <name>` | Shortcut: `arkclaw 答疑助手` ≡ `arkclaw chat 答疑助手`. |
 | `arkclaw ls` | List the claw's managed workspace files. |
 | `arkclaw pull <name> [local]` | Download a managed file to local disk. |
 | `arkclaw push <local> [name]` | Write a local text file into a managed file. |
 | `arkclaw fanout "<msg>" --clawid ci-a --clawid ci-b` | Same message to many claws in parallel. |
-| `arkclaw sessions` | Recent chat sessions on this machine. |
+| `arkclaw sessions [claw]` | An agent's conversations from the server (`--agent` to pick one), newest first — resume with `chat --session <会话ID>`, fork with `--new`. Falls back to the local record when offline / a2a. |
 | `arkclaw profile save/use/list` | Named snapshots of the session config (multi-space / multi-claw). |
 | `arkclaw doctor` | Self-check: login freshness, keychain, pool/STS/endpoint reachability. |
 | `arkclaw schema --json` | Machine-readable command surface (for agents/tooling). |

{arkclaw_webchat_cli-0.6.0 → arkclaw_webchat_cli-0.6.2}/README.md

@@ -7,7 +7,7 @@ at a prompt and for another agent/script (`--json` + exit codes).
 ```bash
 arkclaw init        # one-time interactive setup (asks only what it can't auto-detect)
 arkclaw login       # browser SSO
-arkclaw agents      # list the claws you can chat
+arkclaw agents      # list the agents you can chat
 arkclaw chat ci-xxxxxxxx
 ```
 
@@ -16,7 +16,8 @@ arkclaw chat ci-xxxxxxxx
 ## What it can do
 
 - **Log in as you** — browser SSO (PKCE), short-lived token, auto-refresh. No AK/SK, no client secret, nothing permanent on disk but a token in your OS keychain.
-- **List your agents** — `arkclaw agents` shows the claws you've chatted with (kept locally; add one with `arkclaw chat ci-...`).
+- **List your agents** — `arkclaw agents` shows the agents in your accessible claws (add a claw by chatting it once: `arkclaw chat ci-...`).
+- **Manage agents** — `agents create` / `agents delete` add or remove named agents in a claw, right from the terminal.
 - **Chat** — interactive REPL or one-shot `-m`, streaming token-by-token, with a live "what's it doing" spinner and tool-event trace.
 - **Talk to a specific claw** — by id (`chat ci-...`) or by name (`chat 答疑助手`).
 - **Manage a claw's files** — read/write its managed workspace files (`AGENTS.md`, `SOUL.md`, `MEMORY.md`, …) with `ls` / `pull` / `push`.
@@ -75,14 +76,16 @@ straight to `arkclaw login https://your-space...`. See **[Configuration](#config
 |---|---|
 | `arkclaw init [address]` | One-time interactive setup. Saves the address + (only what isn't auto-discovered) the CLI client and STS role to `~/.arkclaw/defaults.json`, so later commands need no env/flags. |
 | `arkclaw login [space-url]` | Browser SSO login. Uses `init` defaults if you omit the URL. `--transport a2a --endpoint <url>` for an agent endpoint. `--clawid ci-...` sets a default claw. Bare `arkclaw login` re-logs into the previous space. |
-| `arkclaw agents` | List the claws you've used from this machine (local history, newest first) + your default claw. Add a claw by chatting it once (`arkclaw chat ci-...`). Not a space-wide directory. |
+| `arkclaw agents` | List the agents in your accessible claws (verified over the ws; inaccessible claws are pruned). Candidate claws = the ones you've used from this machine + your default — add one by chatting it once (`arkclaw chat ci-...`). Not a space-wide directory. |
+| `arkclaw agents create` | Create a named agent in a claw: `--name` `--role` `--soul` (+ optional `--description`, repeatable `--skill`). Then `chat <claw> --agent <agentId>`. |
+| `arkclaw agents delete <agent>` | Delete a named agent by agentId (`a-...`) or display name. Asks for confirmation unless `--yes`; the `main` agent is protected. |
 | `arkclaw chat [TARGET] [MSG]` | Chat. `TARGET` = a claw id (`ci-...`), an agent name (from `agents`), or a profile. With `MSG` → one-shot; without → interactive REPL. `-f` attach files, `-o` write the reply, `--session NAME` name the conversation, `--approve-all` auto-approve tool runs. |
 | `arkclaw <name>` | Shortcut: `arkclaw 答疑助手` ≡ `arkclaw chat 答疑助手`. |
 | `arkclaw ls` | List the claw's managed workspace files. |
 | `arkclaw pull <name> [local]` | Download a managed file to local disk. |
 | `arkclaw push <local> [name]` | Write a local text file into a managed file. |
 | `arkclaw fanout "<msg>" --clawid ci-a --clawid ci-b` | Same message to many claws in parallel. |
-| `arkclaw sessions` | Recent chat sessions on this machine. |
+| `arkclaw sessions [claw]` | An agent's conversations from the server (`--agent` to pick one), newest first — resume with `chat --session <会话ID>`, fork with `--new`. Falls back to the local record when offline / a2a. |
 | `arkclaw profile save/use/list` | Named snapshots of the session config (multi-space / multi-claw). |
 | `arkclaw doctor` | Self-check: login freshness, keychain, pool/STS/endpoint reachability. |
 | `arkclaw schema --json` | Machine-readable command surface (for agents/tooling). |

{arkclaw_webchat_cli-0.6.0 → arkclaw_webchat_cli-0.6.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "arkclaw-webchat-cli"
-version = "0.6.0"
+version = "0.6.2"
 description = "CLI to chat with an ArkClaw EE space's Claw over enterprise SSO — zero permanent AK/SK."
 readme = "README.md"
 requires-python = ">=3.10"

{arkclaw_webchat_cli-0.6.0 → arkclaw_webchat_cli-0.6.2}/src/ee_claw/cli.py

@@ -161,11 +161,20 @@ def chat(
     message_opt: str | None = typer.Option(
         None, "-m", "--message", help="One-shot message (same as the positional argument)."
     ),
+    agent: str = typer.Option(
+        "main",
+        "--agent",
+        help="Which agent in the claw to talk to (its agentId; see `arkclaw agents`). "
+        "Defaults to the claw's main agent.",
+    ),
     session: str | None = typer.Option(
         None,
         "--session",
-        help="Named server-side session (conversation thread). Defaults to the "
-        "claw's main session; sessions survive CLI restarts.",
+        help="Resume a specific conversation by its 会话ID (see `arkclaw sessions`). "
+        "Omit to continue the agent's main session.",
+    ),
+    new: bool = typer.Option(
+        False, "--new", help="Start a fresh conversation instead of continuing the last one."
     ),
     approve_all: bool = typer.Option(
         False,
@@ -192,6 +201,8 @@ def chat(
             target=target,
             message=message_opt or message,
             session=session,
+            agent=agent,
+            new=new,
             approve_all=approve_all,
             files=list(file) or None,
             output=output,
@@ -200,10 +211,17 @@ def chat(
 
 
 @app.command()
-def sessions(json_mode: bool = _json_opt()) -> None:
-    """List chat sessions this machine has used (most recent first)."""
+def sessions(
+    claw: str | None = typer.Argument(
+        None, metavar="[CLAW]", help="Claw id (ci-...). Omit to use your default claw."
+    ),
+    agent: str = typer.Option("main", "--agent", help="Which agent's conversations to list."),
+    json_mode: bool = _json_opt(),
+) -> None:
+    """List an agent's conversations from the server (newest first). Resume one
+    with `arkclaw chat <claw> --session <会话ID>`, or start fresh with `--new`."""
     emitter = Emitter(json_mode=json_mode)
-    _run(emitter, lambda: flows.do_sessions(emitter))
+    _run(emitter, lambda: flows.do_sessions(emitter, clawid=claw, agent=agent))
 
 
 @app.command(name="ls")
@@ -241,14 +259,76 @@ def push(
     _run(emitter, lambda: flows.do_push(local, remote, emitter, clawid=clawid))
 
 
-@app.command()
-def agents(json_mode: bool = _json_opt()) -> None:
-    """List the agents/claws you can chat with (openclaw: your claws, space
-    auto-discovered; a2a: the agent at the endpoint). Then `chat <id-or-name>`."""
+agents_app = typer.Typer()
+app.add_typer(agents_app, name="agents")
+
+
+@agents_app.callback(invoke_without_command=True)
+def agents(ctx: typer.Context, json_mode: bool = _json_opt()) -> None:
+    """List the agents you can chat with (openclaw: the agents in your accessible
+    claws; a2a: the agent at the endpoint). Then `chat <claw-or-name>`."""
+    if ctx.invoked_subcommand is not None:
+        # `agents --json create …` must honor the group-level flag — stash it
+        # for the subcommand (click contexts inherit obj), never drop it.
+        ctx.obj = {"json": json_mode}
+        return
     emitter = Emitter(json_mode=json_mode)
     _run(emitter, lambda: flows.do_agents(emitter))
 
 
+def _group_json(ctx: typer.Context, json_mode: bool) -> bool:
+    """A subcommand's effective --json: its own flag OR the group-level one."""
+    return json_mode or bool((ctx.obj or {}).get("json"))
+
+
+@agents_app.command("create")
+def agents_create(
+    ctx: typer.Context,
+    name: str = typer.Option(..., "--name", help="Agent display name."),
+    role: str = typer.Option(..., "--role", help="One-line role (what this agent does)."),
+    soul: str = typer.Option(
+        ..., "--soul", help="Persona / system instructions (the agent's SOUL.md)."
+    ),
+    description: str | None = typer.Option(None, "--description", help="Optional description."),
+    skill: list[str] = typer.Option(
+        [], "--skill", help="Skill to enable (repeat for several)."
+    ),
+    clawid: str | None = typer.Option(
+        None, "--clawid", help="Claw instance id (ci-...). Omit to use your default claw."
+    ),
+    json_mode: bool = _json_opt(),
+) -> None:
+    """Create a named agent in a claw. Then `arkclaw chat <claw> --agent <agentId>`."""
+    emitter = Emitter(json_mode=_group_json(ctx, json_mode))
+    _run(
+        emitter,
+        lambda: flows.do_agents_create(
+            emitter,
+            name=name,
+            role=role,
+            soul=soul,
+            description=description,
+            skills=list(skill),
+            clawid=clawid,
+        ),
+    )
+
+
+@agents_app.command("delete")
+def agents_delete(
+    ctx: typer.Context,
+    agent: str = typer.Argument(..., help="agentId (a-...) or display name to delete."),
+    clawid: str | None = typer.Option(
+        None, "--clawid", help="Claw instance id (ci-...). Omit to use your default claw."
+    ),
+    yes: bool = typer.Option(False, "--yes", help="Skip the confirmation prompt."),
+    json_mode: bool = _json_opt(),
+) -> None:
+    """Delete a named agent from a claw (asks for confirmation unless --yes)."""
+    emitter = Emitter(json_mode=_group_json(ctx, json_mode))
+    _run(emitter, lambda: flows.do_agents_delete(emitter, agent, clawid=clawid, yes=yes))
+
+
 @app.command()
 def fanout(
     message: str = typer.Argument(..., help="The message to send to every claw."),
@@ -394,6 +474,8 @@ def _schema_data() -> dict:
     for name, cmd in sorted(getattr(root, "commands", {}).items()):
         subs = getattr(cmd, "commands", None)
         if subs:
+            if getattr(cmd, "invoke_without_command", False):
+                commands.append(info(name, cmd))  # the bare group is a command too
             commands.extend(info(f"{name} {s}", c) for s, c in sorted(subs.items()))
         else:
             commands.append(info(name, cmd))

{arkclaw_webchat_cli-0.6.0 → arkclaw_webchat_cli-0.6.2}/src/ee_claw/flows.py

@@ -20,6 +20,7 @@ import signal
 import sys
 import time
 import urllib.parse
+import uuid
 from typing import Any
 
 from ee_claw import config as config_mod
@@ -51,9 +52,9 @@ from ee_claw.identity import (
     read_chrome_recent_claw,
 )
 from ee_claw.oauth import OAuthClient
-from ee_claw.output import Emitter
+from ee_claw.output import Emitter, sanitize
 from ee_claw.providers import ProviderContext, resolve_token_source
-from ee_claw.sts import assume_role_with_oidc, get_chat_token
+from ee_claw.sts import assume_role_with_oidc
 from ee_claw.transport.a2a import A2ATransport, agent_card
 from ee_claw.transport.base import Approver, Attachment, Transport, TurnEvent, TurnResult
 from ee_claw.transport.openclaw import OpenClawTransport, session_key_for
@@ -116,35 +117,77 @@ def _user_identity(id_token: str | None) -> dict[str, str]:
     return ident
 
 
-def _probe_claw_access(
-    cfg: SessionConfig, id_token: str, claw_ids: list[str]
-) -> tuple[set[str], set[str]]:
-    """Which of ``claw_ids`` the current user can ACTUALLY chat — checked live by
-    minting a (throwaway) ChatToken for each, the only per-user check the CLI's
-    role can do. Returns (accessible, denied). A transient/non-permission error
-    keeps the claw (don't hide it on a network blip). Raises ArkclawError if
-    creds can't be obtained at all (caller falls back to the unchecked list)."""
+def _agent_display_name(agent: dict[str, Any]) -> str:
+    """Friendly name for an agent. The main agent often comes back named "main";
+    show a friendly label instead of leaking the internal id (mirrors the web)."""
+    name = str(agent.get("name") or "").strip()
+    agent_id = str(agent.get("agentId") or "")
+    is_main = bool(agent.get("default")) or agent_id == "main"
+    if is_main and (not name or name == "main"):
+        return "ArkClaw 智能助手"
+    return name or agent_id or "(未命名)"
+
+
+def _list_agents_for_claws(
+    cfg: SessionConfig, creds: dict[str, str], identity: dict[str, str], claw_ids: list[str]
+) -> dict[str, tuple[str, list[dict[str, Any]]]]:
+    """For each claw, list its agents over the ws (``arkclaw.team.agent.list``) —
+    which also proves access (the ChatToken mint denies non-owners). Returns
+    ``clawid → (status, agents)``, status ∈ {"ok","denied","error"}. Parallel."""
     from concurrent.futures import ThreadPoolExecutor
 
-    creds = _openclaw_creds(cfg, id_token)  # may raise (offline / expired / no creds)
-    identity = _user_identity(id_token)
     region = str(cfg.region)
 
-    def check(cid: str) -> tuple[str, bool]:
+    def one(clawid: str) -> tuple[str, str, list[dict[str, Any]]]:
+        t = OpenClawTransport(clawid=clawid, region=region, creds=creds, identity=identity)
         try:
-            get_chat_token(cid, region, creds, identity=identity)
-            return cid, True
+            return clawid, "ok", asyncio.run(t.list_agents())
         except ClawAccessDeniedError:
-            return cid, False
+            return clawid, "denied", []
         except ArkclawError:
-            return cid, True  # transient/other — keep, don't silently drop
+            return clawid, "error", []  # transient — keep the claw, mark unknown
 
-    accessible: set[str] = set()
-    denied: set[str] = set()
+    out: dict[str, tuple[str, list[dict[str, Any]]]] = {}
     with ThreadPoolExecutor(max_workers=min(8, max(1, len(claw_ids)))) as ex:
-        for cid, ok in ex.map(check, claw_ids):
-            (accessible if ok else denied).add(cid)
-    return accessible, denied
+        for clawid, status, agents in ex.map(one, claw_ids):
+            out[clawid] = (status, agents)
+    return out
+
+
+def _resolve_session_key(
+    cfg: SessionConfig, id_token: str, clawid: str, agent: str, session: str | None, new: bool
+) -> str | None:
+    """Compute the OpenClaw sessionKey ``agent:<agentId>:<label>`` for a chat:
+
+    * ``--new``           → a fresh ``agent:<agent>:cli-<uuid>`` (new conversation)
+    * ``--session <id>``  → resume: a full ``agent:…`` key passes through; a short
+                            sessionId is resolved to its key via ``sessions.list``
+    * neither, agent=main → ``None`` (the default ``agent:main:main`` session)
+    * neither, other agent→ ``agent:<agent>:main``
+    """
+    agent = agent or "main"
+    if new:
+        return f"agent:{agent}:cli-{uuid.uuid4()}"
+    if not session:
+        return None if agent == "main" else f"agent:{agent}:main"
+    if session.startswith("agent:"):
+        return session  # already a full sessionKey
+    # A hex token is a 会话ID copied from `arkclaw sessions` → resolve to its key.
+    if re.fullmatch(r"[0-9a-f]{6,}", session):
+        creds = _openclaw_creds(cfg, id_token)
+        t = OpenClawTransport(
+            clawid=clawid, region=str(cfg.region), creds=creds, identity=_user_identity(id_token)
+        )
+        for s in asyncio.run(t.list_sessions(agent)):
+            sid = str(s.get("sessionId") or "")
+            if sid and (sid == session or sid.startswith(session)):
+                return str(s.get("key") or f"agent:{agent}:{session}")
+        raise ValidationError(
+            f"会话 {session!r} 不存在。",
+            hint="用 `arkclaw sessions` 查看现有会话,或加 `--new` 开新会话。",
+        )
+    # Otherwise a human-named session label (created/resumed by this key).
+    return f"agent:{agent}:{session}"
 
 
 def _normalize(url: str) -> tuple[str, str]:
@@ -783,6 +826,8 @@ def do_chat(
     target: str | None = None,
     message: str | None = None,
     session: str | None = None,
+    agent: str = "main",
+    new: bool = False,
     approve_all: bool = False,
     files: list[str] | None = None,
     output: str | None = None,
@@ -838,6 +883,12 @@ def do_chat(
         )
 
     approver = _build_approver(emitter, approve_all=approve_all, interactive=interactive)
+    # Resolve agent + session → a concrete sessionKey (openclaw only; a2a uses
+    # the session name as the context label).
+    if cfg.transport == "openclaw":
+        effective_claw = clawid or cfg.claw
+        if effective_claw:
+            session = _resolve_session_key(cfg, id_token, effective_claw, agent, session, new)
     target, transport = _target_transport(
         cfg, clawid, id_token, session=session, approver=approver
     )
@@ -879,8 +930,9 @@ def do_chat(
         pass
     emitter.line(
         f"ArkClaw chat · {target}"
+        + (f" · agent {agent}" if agent and agent != "main" else "")
+        + (f" · 会话 {session.split(':')[-1][:16]}" if session else "")
         + (f" · 空间 {cfg.space}" if cfg.space and cfg.space != target else "")
-        + (f" · 会话 {session}" if session else "")
         + " (Ctrl+C 退出)"
     )
     while True:
@@ -911,11 +963,54 @@ def do_chat(
             emitter.line("")
 
 
-def do_sessions(emitter: Emitter) -> dict[str, Any]:
-    """``arkclaw sessions``: the local view of server-side sessions (which
-    space/claw/session tuples this machine has talked to). Server-side
-    listing + replay land with gate G2."""
-    rows = config_mod.list_sessions()
+def do_sessions(
+    emitter: Emitter, clawid: str | None = None, agent: str = "main"
+) -> dict[str, Any]:
+    """``arkclaw sessions [<claw>] [--agent <id>]``: the conversations of an agent
+    in a claw, from the server (ws ``sessions.list``) — newest first. Resume one
+    with ``arkclaw chat <claw> --session <会话ID>``. Falls back to the local
+    record for a2a / when the claw can't be reached."""
+    cfg = config_mod.load_config()
+    target = (clawid or (cfg.claw if cfg else None)) if cfg else None
+    if cfg and cfg.space and cfg.transport == "openclaw" and target:
+        try:
+            _, id_token = _load_session(cfg)
+            creds = _openclaw_creds(cfg, id_token)
+            t = OpenClawTransport(
+                clawid=target, region=str(cfg.region), creds=creds, identity=_user_identity(id_token)
+            )
+            sessions = asyncio.run(t.list_sessions(agent))
+            sessions.sort(key=lambda s: float(s.get("updatedAt") or 0), reverse=True)
+            emitter.line(f"★ claw {target} · agent {agent} · 空间 {cfg.space}")
+            if sessions:
+                emitter.table(
+                    ["标题", "上次活动", "会话ID", "状态"],
+                    [
+                        [
+                            (str(s.get("derivedTitle") or "(无标题)"))[:48],
+                            _ago_ms(s.get("updatedAt")),
+                            str(s.get("sessionId") or "")[:8],
+                            str(s.get("status") or "—"),
+                        ]
+                        for s in sessions
+                    ],
+                )
+                emitter.line("  续聊: arkclaw chat <claw> --session <会话ID>;新开: --new")
+            else:
+                emitter.line("  该 agent 还没有会话。`arkclaw chat` 开始第一段对话。")
+            return {
+                "claw": target, "agent": agent,
+                "sessions": [
+                    {"sessionId": s.get("sessionId"), "key": s.get("key"),
+                     "title": s.get("derivedTitle"), "updatedAt": s.get("updatedAt"),
+                     "status": s.get("status")}
+                    for s in sessions
+                ],
+            }
+        except ArkclawError as e:
+            emitter.line(f"  ⚠ 无法从服务端列会话({e.code}),回退本地记录:")
+
+    rows = config_mod.list_sessions()  # a2a / not-logged-in / no-claw / server-error fallback
     if rows:
         emitter.table(
             ["会话", "目标", "空间", "最近使用"],
@@ -964,13 +1059,15 @@ def _ago(ts: object) -> str:
 
 
 def do_agents(emitter: Emitter) -> dict[str, Any]:
-    """``arkclaw agents``: the agents/claws you can chat with.
+    """``arkclaw agents``: the agents you can chat with.
 
-    openclaw → the claws YOU have used from this machine (kept locally, newest
-    first), plus your default claw. This is deliberately NOT a server-side
-    enumeration of the space — that API returns every member's claws to anyone
-    (no per-user scoping is reachable by the CLI's role), so we don't call it.
-    You add a claw to this list by chatting it once: ``arkclaw chat ci-...``.
+    openclaw → the AGENTS hosted in your accessible claws. The candidate claws
+    are the ones YOU have used from this machine (kept locally, newest first)
+    plus your default; for each we list its agents over the ws
+    (``arkclaw.team.agent.list``), which also verifies access — inaccessible
+    claws are pruned. This is NOT a space-wide server enumeration (not per-user
+    scoped for the CLI's role). You add a claw by chatting it once: ``arkclaw
+    chat ci-...``.
 
     a2a → the agent at the endpoint (its card). Profiles live under ``arkclaw
     profile``, full conversation history under ``arkclaw sessions``."""
@@ -1030,11 +1127,11 @@ def do_agents(emitter: Emitter) -> dict[str, Any]:
             )
     elif cfg.transport == "openclaw":
         emitter.line(f"★ 当前登录(openclaw)· 空间 {cfg.space}")
-        # Candidates = the claws YOU have used from this machine (local history) +
-        # your default — NOT a server enumeration (the space-wide list isn't
-        # per-user scoped for the CLI's role). We then VERIFY access to each by
-        # minting a throwaway ChatToken, so only claws you can actually chat are
-        # shown; denied ones are pruned from history (and cleared as default).
+        # The chat-able units are AGENTS, and one claw hosts several. Candidates
+        # are the claws YOU have used from this machine (local history) + your
+        # default; for each we list its agents over the ws (which also proves
+        # access). Inaccessible claws are pruned from history (+ cleared as
+        # default). NOT a space-wide server enumeration (not per-user scoped).
         seen: dict[str, float] = {}
         for s in config_mod.list_sessions():
             cid = s.get("claw")
@@ -1045,43 +1142,56 @@ def do_agents(emitter: Emitter) -> dict[str, Any]:
             seen[str(cfg.claw)] = 0.0  # the default claw, even if not chatted yet
 
         claw_ids = sorted(seen, key=lambda c: seen[c], reverse=True)
+        rows: list[list[str]] = []
+        agents_data: list[dict[str, Any]] = []
         checked = False
         if claw_ids:
             if not emitter.json:
-                emitter.line("  核对访问权限中…")
+                emitter.line("  列出 agents…")
             try:
                 _, id_token = _load_session(cfg)
-                accessible, denied = _probe_claw_access(cfg, id_token, claw_ids)
+                creds = _openclaw_creds(cfg, id_token)
+                identity = _user_identity(id_token)
+                results = _list_agents_for_claws(cfg, creds, identity, claw_ids)
                 checked = True
-                for cid in denied:
-                    config_mod.forget_claw(str(cfg.space), cid)  # stop listing it
-                    if cfg.claw == cid:
-                        config_mod.save_config(dataclasses.replace(cfg, claw=None))
-                        cfg = config_mod.load_config() or cfg
-                        current["default_claw"] = cfg.claw
-                claw_ids = [c for c in claw_ids if c in accessible]
+                for clawid in claw_ids:
+                    status, agents = results[clawid]
+                    if status == "denied":
+                        config_mod.forget_claw(str(cfg.space), clawid)  # stop listing it
+                        if cfg.claw == clawid:
+                            config_mod.save_config(dataclasses.replace(cfg, claw=None))
+                            cfg = config_mod.load_config() or cfg
+                            current["default_claw"] = cfg.claw
+                        continue
+                    if status == "error" or not agents:
+                        rows.append(["(无法列出 agent)", "—", clawid, "★" if clawid == cfg.claw else ""])
+                        continue
+                    for a in agents:
+                        aid = str(a.get("agentId") or "")
+                        is_main = bool(a.get("default")) or aid == "main"
+                        rows.append([
+                            _agent_display_name(a), aid or "—", clawid,
+                            "★" if (clawid == cfg.claw and is_main) else "",
+                        ])
+                        agents_data.append({
+                            "clawId": clawid, "agentId": aid, "name": _agent_display_name(a),
+                            "description": a.get("description"), "default": is_main,
+                        })
             except ArkclawError:
-                checked = False  # offline / expired / no creds → show unchecked
+                checked = False  # offline / expired / no creds → can't list agents
 
-        claws = [{"ClawInstanceId": cid, "last_used": seen[cid]} for cid in claw_ids]
-        current["claws"] = claws
+        current["agents"] = agents_data
         current["source"] = "verified" if checked else "local-history-unchecked"
-        if claws:
+        if checked and rows:
+            emitter.table(["Agent", "agentId", "所属 Claw", "默认"], rows)
+        elif checked:
+            emitter.line("  本空间没有你可访问的 claw / agent(历史里的都已无权或不存在)。")
+        elif claw_ids:
+            emitter.line("  ⚠ 未能连接核对(离线/会话过期),无法列出 agent;以下为本地历史的 claw:")
             emitter.table(
-                ["Claw(可 chat)", "上次使用", "默认"],
-                [
-                    [
-                        str(c["ClawInstanceId"]),
-                        _ago(c["last_used"]) if c["last_used"] else "—",
-                        "★" if c["ClawInstanceId"] == cfg.claw else "",
-                    ]
-                    for c in claws
-                ],
+                ["Claw", "上次使用"],
+                [[c, _ago(seen[c]) if seen[c] else "—"] for c in claw_ids],
             )
-            if not checked:
-                emitter.line("  ⚠ 未能核对权限(离线/会话过期),以上为本地历史,可能含你无权访问的。")
-        elif checked:
-            emitter.line("  你在本空间没有可访问的 claw(历史里的都已无权或不存在)。")
         else:
             emitter.line("  还没用过任何 claw。用 `arkclaw chat ci-xxxx` 开始,之后这里会记住它。")
 
@@ -1091,15 +1201,14 @@ def do_agents(emitter: Emitter) -> dict[str, Any]:
     return {"current": current}
 
 
-def _openclaw_file_transport(clawid: str | None) -> tuple[OpenClawTransport, str]:
-    """Build an OpenClawTransport for file transfer (openclaw-only). Returns
-    (transport, clawid)."""
+def _openclaw_claw_transport(
+    clawid: str | None, *, feature: str, hint: str
+) -> tuple[OpenClawTransport, str]:
+    """Build an OpenClawTransport against the given (or default) claw for an
+    openclaw-only feature. Returns (transport, clawid)."""
     cfg, id_token = _load_session()
     if cfg.transport != "openclaw":
-        raise ValidationError(
-            "文件传输目前仅支持 openclaw transport(claw 工作区文件)。",
-            hint="A2A agent 没有可直传的工作区文件系统。",
-        )
+        raise ValidationError(f"{feature}目前仅支持 openclaw transport。", hint=hint)
     clawid = clawid or cfg.claw
     if not clawid:
         raise NoClawError("未指定 claw。", hint="加 --clawid <ci-...>。")
@@ -1111,6 +1220,104 @@ def _openclaw_file_transport(clawid: str | None) -> tuple[OpenClawTransport, str
     ), clawid
 
 
+def _openclaw_file_transport(clawid: str | None) -> tuple[OpenClawTransport, str]:
+    """Build an OpenClawTransport for file transfer (openclaw-only). Returns
+    (transport, clawid)."""
+    return _openclaw_claw_transport(
+        clawid, feature="文件传输", hint="A2A agent 没有可直传的工作区文件系统。"
+    )
+
+
+def _agent_mgmt_transport(clawid: str | None) -> tuple[OpenClawTransport, str]:
+    return _openclaw_claw_transport(
+        clawid, feature="agent 管理", hint="A2A 模式连接的是单个 agent 端点,没有可管理的 claw。"
+    )
+
+
+def do_agents_create(
+    emitter: Emitter,
+    *,
+    name: str,
+    role: str,
+    soul: str,
+    description: str | None = None,
+    skills: list[str] | None = None,
+    clawid: str | None = None,
+) -> dict[str, Any]:
+    """``arkclaw agents create``: create a named agent in a claw (ws RPC
+    ``arkclaw.team.agent.create``; live-calibrated 2026-06-10). The server
+    requires name+role+soul; skills may be empty."""
+    for label, value in (("--name", name), ("--role", role), ("--soul", soul)):
+        if not value.strip():
+            raise ValidationError(f"{label} 不能为空。")
+    if name.strip().startswith("a-") or name.strip() == "main":
+        raise ValidationError(
+            f"--name 不能是 {name.strip()!r} — 会与 agentId 命名空间(a-…/main)冲突。"
+        )
+    transport, clawid = _agent_mgmt_transport(clawid)
+    raw = asyncio.run(
+        transport.create_agent(
+            name=name, role=role, soul=soul, description=description, skills=skills or []
+        )
+    )
+    agent = redact_obj(raw)
+    assert isinstance(agent, dict)  # redact_obj preserves the dict shape
+    aid = str(agent.get("agentId") or "")
+    emitter.line(f"✓ 已创建 agent {agent.get('name') or name}({aid or '?'})· claw {clawid}")
+    if aid:
+        emitter.line(f"  开聊: arkclaw chat {clawid} --agent {aid}")
+    return {"claw": clawid, "agent": agent}
+
+
+def do_agents_delete(
+    emitter: Emitter, agent: str, *, clawid: str | None = None, yes: bool = False
+) -> dict[str, Any]:
+    """``arkclaw agents delete``: remove a named agent from a claw (ws RPC
+    ``arkclaw.team.agent.delete``). Accepts an agentId (``a-…``) or the agent's
+    display name; either way the target is resolved against the claw's live
+    agent list first — so a typo'd id can't delete anything, an ``a-…``-looking
+    display name can't shadow another agent's id, and the claw's default agent
+    (``main`` or ``default: true``) stays protected."""
+    if agent == "main":  # fail fast — no network needed to refuse this
+        raise ValidationError("默认(main)agent 不能删除。")
+    transport, clawid = _agent_mgmt_transport(clawid)
+    agents = asyncio.run(transport.list_agents())
+    matches = [a for a in agents if str(a.get("agentId") or "") == agent]
+    if not matches:  # not an id → try the display name
+        matches = [a for a in agents if str(a.get("name") or "") == agent]
+        if len(matches) > 1:
+            ids = ", ".join(str(a.get("agentId") or "?") for a in matches)
+            raise ValidationError(
+                f"名称 {agent!r} 对应多个 agent({ids}),请直接用 agentId。"
+            )
+    if not matches:
+        raise ValidationError(
+            f"claw {clawid} 里没有 agentId 或名称为 {agent!r} 的 agent。",
+            hint="用 `arkclaw agents` 查看 agentId 与名称。",
+        )
+    target = matches[0]
+    agent_id = str(target.get("agentId") or "")
+    if not agent_id:
+        raise ValidationError(f"服务端没有给出 {agent!r} 的 agentId,无法安全删除。")
+    if agent_id == "main" or bool(target.get("default")):
+        raise ValidationError("默认(main)agent 不能删除。")
+    if not yes:
+        if emitter.json or not sys.stdin.isatty():
+            raise ValidationError("headless 删除必须显式 --yes。")
+        # agent_id is upstream content: sanitize before it touches the TTY —
+        # input() bypasses Emitter.line's control-char stripping.
+        prompt = sanitize(f"确认删除 claw {clawid} 的 agent {agent_id}? [y/N] ")
+        answer = input(prompt).strip().lower()
+        if answer not in ("y", "yes"):
+            emitter.line("已取消。")
+            return {"cancelled": True}
+    result = redact_obj(asyncio.run(transport.delete_agent(agent_id)))
+    if isinstance(result, dict) and result.get("success") is False:
+        raise NetworkError(f"claw 未确认删除 agent {agent_id}(success=false)。")
+    emitter.line(f"✓ 已删除 agent {agent_id} · claw {clawid}")
+    return {"claw": clawid, "agentId": agent_id, "result": result}
+
+
 def do_ls(emitter: Emitter, *, clawid: str | None = None) -> dict[str, Any]:
     """``arkclaw ls``: list files in the claw workspace."""
     transport, clawid = _openclaw_file_transport(clawid)
@@ -1316,7 +1523,7 @@ def do_claw(
     if op == "delete" and not yes:
         if emitter.json or not sys.stdin.isatty():
             raise ValidationError("headless 删除必须显式 --yes。")
-        answer = input(f"确认删除 claw {clawid}? [y/N] ").strip().lower()
+        answer = input(sanitize(f"确认删除 claw {clawid}? [y/N] ")).strip().lower()
         if answer not in ("y", "yes"):
             emitter.line("已取消。")
             return {"cancelled": True}

{arkclaw_webchat_cli-0.6.0 → arkclaw_webchat_cli-0.6.2}/src/ee_claw/transport/openclaw.py

@@ -451,9 +451,10 @@ class OpenClawTransport:
     #   agents.files.get  {agentId, name}        → {file:{name,path,size,content}}
     #   agents.files.set  {agentId, name, content} → write
 
-    async def _request(self, method: str, params: dict[str, Any]) -> dict[str, Any]:
-        """connect (hello-ok) → one control request → its res payload. Errors
-        are redacted; the token-bearing URL is never echoed."""
+    async def _request(self, method: str, params: dict[str, Any]) -> Any:
+        """connect (hello-ok) → one control request → its res payload (dict or
+        list, depending on the method). Errors are redacted; the token-bearing
+        URL is never echoed."""
         chat_token, endpoint = get_chat_token(self.clawid, self.region, self.creds, identity=self.identity)
         url = (
             f"wss://{endpoint}/?chatToken={urllib.parse.quote(chat_token)}"
@@ -510,3 +511,60 @@ class OpenClawTransport:
         return await self._request(
             "agents.files.set", {"agentId": agent_id, "name": name, "content": content}
         )
+
+    async def list_agents(self) -> list[dict[str, Any]]:
+        """The agents living in this claw (ws RPC ``arkclaw.team.agent.list``).
+        Each item: ``{agentId, name, description?, default?}``. Raises
+        ClawAccessDeniedError (via the ChatToken mint) if the user can't access
+        this claw."""
+        payload = await self._request("arkclaw.team.agent.list", {})
+        if isinstance(payload, list):
+            return [a for a in payload if isinstance(a, dict)]
+        if isinstance(payload, dict):  # some gateways wrap the array
+            for k in ("data", "agents", "list", "items"):
+                v = payload.get(k)
+                if isinstance(v, list):
+                    return [a for a in v if isinstance(a, dict)]
+        return []
+
+    async def create_agent(
+        self,
+        *,
+        name: str,
+        role: str,
+        soul: str,
+        description: str | None = None,
+        skills: Sequence[str] = (),
+    ) -> dict[str, Any]:
+        """Create a named agent in this claw (ws RPC ``arkclaw.team.agent.create``).
+        The server requires name + role + soul + skills (array, may be empty);
+        returns the created agent ``{agentId, name, role, soul, …}``."""
+        params: dict[str, Any] = {
+            "name": name,
+            "role": role,
+            "soul": soul,
+            "skills": list(skills),
+        }
+        if description:
+            params["description"] = description
+        payload = await self._request("arkclaw.team.agent.create", params)
+        return payload if isinstance(payload, dict) else {}
+
+    async def delete_agent(self, agent_id: str) -> dict[str, Any]:
+        """Delete an agent from this claw (ws RPC ``arkclaw.team.agent.delete``).
+        Returns the server ack (``{success: true}``)."""
+        payload = await self._request("arkclaw.team.agent.delete", {"agentId": agent_id})
+        return payload if isinstance(payload, dict) else {}
+
+    async def list_sessions(self, agent_id: str = "main") -> list[dict[str, Any]]:
+        """An agent's conversations (ws RPC ``sessions.list``). Each item:
+        ``{key, sessionId, derivedTitle?, updatedAt, status, ...}`` — ``key`` is
+        the sessionKey to resume with."""
+        payload = await self._request(
+            "sessions.list", {"agentId": agent_id, "includeDerivedTitles": True}
+        )
+        if isinstance(payload, dict):
+            sessions = payload.get("sessions")
+            if isinstance(sessions, list):
+                return [s for s in sessions if isinstance(s, dict)]
+        return []