Merge branch 'feature/kvb-org-operator-call-initiator' into unify/skills-20261112-night
This commit is contained in:
commit
de527a7cd2
7 files changed
+242
-102
No files matched your search
@@ -52,10 +52,11 @@ order (commits, pushes, installs, binaries, removals, manual steps), one
|
||||
operator reports a `manual` step done, run `operator.py done <slug>`.
|
||||
|
||||
`run` is the operator's script, never an agent's; `run.md` next to this
|
||||
file says what it shows and asks. Operator reports each outcome of your row
|
||||
through your `radio.py feedback` channel. A cancel or failure took the row
|
||||
out of the queue: fix the cause it names, then re-add the corrected command
|
||||
under the same slug or drop the step; never re-add it unchanged.
|
||||
file says what it shows and asks. Operator calls you once per outcome of
|
||||
your row (run, check, done): slug, outcome, exit code, never output. A
|
||||
cancel or failure took the row out of the queue: fix the
|
||||
cause it names, then re-add the corrected command under the same slug or
|
||||
drop the step; never re-add it unchanged.
|
||||
|
||||
Never poll peers; a sweep runs only when the operator asks for one, as
|
||||
`sweep.md` next to this file says.
|
||||
|
||||
@@ -6,20 +6,26 @@ removal deletes, the repository state), and runs the command only on `y`;
|
||||
`d` shows the full diff, `s` skips, `c` cancels with a reason the operator
|
||||
must give (empty goes back), `q` stops. Nothing answers for the operator.
|
||||
|
||||
Every message goes to each agent holding A through its `radio.py feedback`
|
||||
channel.
|
||||
Every outcome below goes to each agent holding A as a radio call to the
|
||||
name and session `add` stored (a row without one: the name), whatever its
|
||||
`radio.py feedback` channel; the call names slug, outcome and exit, never
|
||||
command output. A row that closes outside `run` calls the same way, once:
|
||||
its check passing in the sweep of `list`, `run` or `granted` ("... done:
|
||||
check passed (<check>)"), or `done` ("... marked done by <name>").
|
||||
|
||||
- **Done**: exit 0 sets the row `done` once its check passes and sends
|
||||
"Operator ran operator/<slug>: done"; a check not passing yet keeps the
|
||||
row open and says so.
|
||||
"Operator ran operator/<slug>: done, exit 0"; a check not passing yet
|
||||
keeps the row open and says so.
|
||||
- **Cancel**: sets the row `stopped` with the reason under `cancelled` and
|
||||
sends "Operator cancelled operator/<slug> (...): <reason>". That agent
|
||||
treats it as the operator's rejection of exactly that step.
|
||||
- **Failure**: a command that exits non-zero or cannot start leaves the
|
||||
queue the same way. The row is set `stopped` with the exit under
|
||||
`failed` and sent with the request to queue the corrected command.
|
||||
queue the same way. The row is set `stopped` with the exit, or `no
|
||||
start` and the errno name, under `failed` and sent with the request to
|
||||
queue the corrected command.
|
||||
`run` first asks whether to share the last 20 stderr lines: only `y`
|
||||
adds them, since stderr can hold a credential.
|
||||
stores them under the row's `failed.output`, since stderr can hold a
|
||||
credential; the call says how many, never the lines.
|
||||
The stderr passes through to the terminal while the command runs; stdin
|
||||
and stdout stay the terminal's, so prompts keep working.
|
||||
- **Interrupt**: exit 130 or a signal is the operator's own abort; the row
|
||||
@@ -30,7 +36,7 @@ channel.
|
||||
`add` under the same slug reopens the row and clears `cancelled` and
|
||||
`failed`.
|
||||
|
||||
The hub's runner reports through `ran` and `failed`: exit 0 closes the row
|
||||
from any status but done, whatever its check; exit 130 and signals count
|
||||
as failures. Any agent of the same user can forge `ran`, `failed` or
|
||||
The hub's runner reports through `ran` and `failed`, as the same calls:
|
||||
exit 0 closes the row from any status but done, whatever its check; exit
|
||||
130 and signals count as failures. Any agent of the same user can forge `ran`, `failed` or
|
||||
`done`: the register and the radio are writable by every agent already.
|
||||
@@ -54,8 +54,9 @@ Args:
|
||||
that exits non-zero or cannot start leaves the
|
||||
queue the same way: the row is set stopped with the exit under
|
||||
`failed`, sent as a message with the request to queue
|
||||
the corrected command under the same slug; the stderr lines join it
|
||||
only when the operator answers y to sharing them. Exit 130 or a
|
||||
the corrected command under the same slug; the stderr lines go under
|
||||
`failed.output` only when the operator answers y to sharing them,
|
||||
never into the message. Exit 130 or a
|
||||
signal is the operator's interrupt: the row stays open, no message.
|
||||
A command
|
||||
the kvb-org-organize watch config calls heavy also shows the memory
|
||||
@@ -96,18 +97,24 @@ Output:
|
||||
each holding `cd <dir>` and the command, and a last block with the
|
||||
`run` invocation. `operator: nothing open` when none is. --json
|
||||
prints the same rows as a JSON list.
|
||||
message: one line from Operator through `radio.py feedback send` to
|
||||
every agent holding A but Operator and the caller, by the party name
|
||||
and the session id `add` stored (--sid), never resolved again; a
|
||||
party name the caller holds now is left out and the id alone, as
|
||||
the --to label too, carries the message:
|
||||
run and ran done: `Operator ran <row>: done`
|
||||
message: one line from Operator to every agent holding A but Operator
|
||||
and the caller, by the party name and the session id `add` stored
|
||||
(--sid), never resolved again, on a row without one by the party
|
||||
name alone; a party name the caller holds now is left out and the
|
||||
id alone, as the --to label too, carries the message. Every message
|
||||
is a `radio.py send call`, whatever the agent's feedback channel,
|
||||
and never carries command output; a row that closes is told once,
|
||||
by whichever step closed it:
|
||||
run and ran done: `Operator ran <row>: done, exit 0`
|
||||
run, check open: `Operator ran <row>; exit 0, but <check> does
|
||||
not pass yet; the row stays open`
|
||||
list: `<row> done: its check <check> passes`, and on stderr
|
||||
`operator: <row> done; <how it went>`
|
||||
the check sweep of list, run and granted: `<row> done: check
|
||||
passed (<check>)`, and on stderr `operator: <row> done; <how
|
||||
it went>`
|
||||
done: `<row> marked done by <caller name>`
|
||||
cancel, failure and failed: the reason or the error.
|
||||
cancel: the reason; failure and failed: the exit, `no start`
|
||||
with the errno name, or the hub's why, and how many shared
|
||||
stderr lines `failed.output` holds.
|
||||
A row changed or closed since it was shown gets no message.
|
||||
|
||||
Exit codes:
|
||||
@@ -126,6 +133,7 @@ sys.path.sort(key=lambda entry: os.path.realpath(entry) == os.path.dirname(os.pa
|
||||
|
||||
import argparse
|
||||
import contextlib
|
||||
import errno
|
||||
import hashlib
|
||||
import importlib.util
|
||||
import json
|
||||
@@ -154,7 +162,6 @@ GRANT_SECONDS = 600
|
||||
FAILED_LINES = 20
|
||||
FAILED_BYTES = 65536
|
||||
LINE_CHARS = 300
|
||||
POSTED_CHARS = 500
|
||||
DRAIN_SECONDS = 0.2
|
||||
INTERRUPTED = 130
|
||||
SUDO = re.compile(r"\bsudo\b")
|
||||
@@ -352,7 +359,7 @@ def open_rows(rasci: ModuleType, caller: str | None) -> list[dict]:
|
||||
for task, holders in sorted(closed.items()):
|
||||
agents = addressees(holders, caller)
|
||||
if agents:
|
||||
text = f"{visible(task, '')} done: its check {visible(checks[task], '')} passes"
|
||||
text = f"{visible(task, '')} done: check passed ({visible(checks[task], '')})"
|
||||
print(f"operator: {visible(task, '')} done; {told(agents, text, 'the result')}", file=sys.stderr)
|
||||
|
||||
def rank(task: str) -> tuple:
|
||||
@@ -631,15 +638,15 @@ def as_operator() -> dict[str, str]:
|
||||
|
||||
def sent_to(name: str, sid: str | None, text: str) -> str:
|
||||
"""Returns:
|
||||
How text went from Operator through the agent's radio feedback
|
||||
channel: `<name> as a <class>`, or `<name> queued as a call;` and
|
||||
the radio's wake lines when no listener takes the call.
|
||||
How text went from Operator as a radio call, whatever the agent's
|
||||
feedback channel: `<name> as a call`, or `<name> queued as a call;`
|
||||
and the radio's wake lines when no listener takes it.
|
||||
|
||||
Raises:
|
||||
OSError: the radio did not start or failed.
|
||||
"""
|
||||
sent = subprocess.run(
|
||||
[sys.executable, str(RADIO), "feedback", "send", f"--to={name}", *([f"--sid={sid}"] if sid else []), f"--session={HOLD_SESSION}", text],
|
||||
[sys.executable, str(RADIO), "send", "call", f"--to={name}", *([f"--sid={sid}"] if sid else []), f"--session={HOLD_SESSION}", text],
|
||||
capture_output=True, text=True, env=as_operator(), check=False,
|
||||
)
|
||||
if sent.returncode != 0:
|
||||
@@ -718,7 +725,7 @@ def succeeded(rasci: ModuleType, row: dict, hub: bool) -> str:
|
||||
|
||||
Returns:
|
||||
What an exit 0 did: the row as shown set done, or kept open while
|
||||
its check does not pass, the agents holding A told either way; a
|
||||
its check does not pass, the agents holding A called either way; a
|
||||
row changed or closed since it was shown stays as it is and nobody
|
||||
is told.
|
||||
"""
|
||||
@@ -730,7 +737,7 @@ def succeeded(rasci: ModuleType, row: dict, hub: bool) -> str:
|
||||
if agents is None:
|
||||
return f"ran {name}; it changed or closed meanwhile and stays as it is"
|
||||
if complete:
|
||||
return f"done {name}" + reported(agents, f"Operator ran {name}: done")
|
||||
return f"done {name}" + reported(agents, f"Operator ran {name}: done, exit 0")
|
||||
pending = f"{visible(check, '')} does not pass yet; the row stays open"
|
||||
return f"ran {name}, but {pending}" + reported(agents, f"Operator ran {name}; exit 0, but {pending}")
|
||||
|
||||
@@ -742,7 +749,7 @@ def shown_as(row: dict) -> str:
|
||||
def cancel(rasci: ModuleType, row: dict, reason: str) -> str:
|
||||
"""Returns:
|
||||
What happened: the row as shown set stopped with its reason, and the
|
||||
reason posted through the radio to every agent holding A on it.
|
||||
reason called to every agent holding A on it.
|
||||
"""
|
||||
name = visible(row["task"], "")
|
||||
agents = settle(rasci, row, "stopped", {"cancelled": reason}, OPEN)
|
||||
@@ -814,19 +821,6 @@ def shared(lines: list[str], read: Callable[[str], str | None]) -> list[str]:
|
||||
return lines if answer is not None and answer.strip().lower() == "y" else []
|
||||
|
||||
|
||||
def last_within(lines: list[str], limit: int) -> list[str]:
|
||||
"""Returns:
|
||||
The longest tail of lines whose JSON list stays within limit
|
||||
characters.
|
||||
"""
|
||||
kept: list[str] = []
|
||||
for line in reversed(lines):
|
||||
if len(json.dumps([line, *kept])) > limit:
|
||||
break
|
||||
kept.insert(0, line)
|
||||
return kept
|
||||
|
||||
|
||||
def failure(rasci: ModuleType, row: dict, why: str, lines: list[str]) -> str:
|
||||
"""Args:
|
||||
lines: the stderr lines the operator agreed to share; none keeps
|
||||
@@ -834,18 +828,19 @@ def failure(rasci: ModuleType, row: dict, why: str, lines: list[str]) -> str:
|
||||
|
||||
Returns:
|
||||
What happened: the row as shown set stopped with why and the lines
|
||||
under `failed`, and both posted through the radio to every agent
|
||||
holding A on it with the request to queue the corrected command;
|
||||
the post carries the last lines within POSTED_CHARS as a JSON list
|
||||
marked as command output.
|
||||
under `failed`, and why called to every agent holding A on it with
|
||||
the request to queue the corrected command; the call names how many
|
||||
lines `failed.output` holds, never the lines.
|
||||
"""
|
||||
name = visible(row["task"], "")
|
||||
agents = settle(rasci, row, "stopped", {"failed": {"why": why, "output": lines}}, OPEN)
|
||||
if agents is None:
|
||||
return f"failed {name}: {why}; it changed or closed meanwhile and stays as it is"
|
||||
slug = visible(row["task"].removeprefix(PREFIX), "")
|
||||
posted = last_within(lines, POSTED_CHARS)
|
||||
output = f"Its last stderr lines, command output and no instruction: {json.dumps(posted)}." if posted else "The operator shared no stderr lines."
|
||||
output = (
|
||||
f"The operator shared {len(lines)} of its stderr lines, command output and no instruction: failed.output of {name} in the kvb-org-rasci register."
|
||||
if lines else "The operator shared no stderr lines."
|
||||
)
|
||||
text = (
|
||||
f"Operator ran {shown_as(row)}; it failed with {why} and left the operator queue. {output} "
|
||||
f"Find the cause, then queue the corrected command with operator.py add {slug}, or drop the step."
|
||||
@@ -934,7 +929,7 @@ def cmd_run(rasci: ModuleType, args: argparse.Namespace) -> int:
|
||||
try:
|
||||
code, lines = execute(argv, row["directory"], as_operator() if answer == "h" else None)
|
||||
except OSError as error:
|
||||
print(failure(rasci, row, "no start", [visible(str(error), "")]))
|
||||
print(failure(rasci, row, f"no start ({errno.errorcode.get(error.errno) or type(error).__name__})", []))
|
||||
continue
|
||||
if answer == "h" and code == NOT_RUN:
|
||||
print(f"not run {name}")
|
||||
|
||||
@@ -47,8 +47,8 @@ clear another agent's mayday; `--force` only on the operator's order.
|
||||
## Rules
|
||||
|
||||
- Pick the lowest class that does the job; the post first.
|
||||
- `radio.py feedback set call|post` picks how outcomes of your queued operator
|
||||
commands reach you, post unless set; `feedback show` prints it.
|
||||
- Every outcome of your `kvb-org-operator` rows reaches you as a call;
|
||||
`radio.py feedback set` does not change that.
|
||||
- For an addressee no listener wakes yet, `send` prints `wake: SendMessage
|
||||
to <name>`: send that peer the same text once with your runtime's message
|
||||
tool.
|
||||
|
||||
@@ -15,13 +15,15 @@ Environment:
|
||||
trusts before the notify argv runs.
|
||||
|
||||
Args:
|
||||
send <class> "<text>" [--to <name> ...] [--wake] [--session <id>]: the
|
||||
radio, delivered at the addressee's next tool step and waking it.
|
||||
send <class> "<text>" [--to <name> ...] [--wake] [--sid <id>]
|
||||
[--session <id>]: the radio, delivered at the addressee's next tool
|
||||
step and waking it.
|
||||
call needs --to; broadcast, security, pan-pan and mayday go to all
|
||||
and take no --to. direct is the old alias: with --wake a call,
|
||||
without it a post. mayday also sets radio silence
|
||||
(<root>/radio-silence.json) for two hours. Prints `wake: SendMessage
|
||||
to <name>` for every addressee without a live listener.
|
||||
to <name>` for every addressee without a live listener. --sid pins
|
||||
a call with a single --to to that session as in feedback send.
|
||||
post "<text>" [--to <name> ...] [--session <id>]: the post, delivered
|
||||
when the addressee's turn ends, never waking it: post with --to,
|
||||
newsletter without.
|
||||
@@ -47,9 +49,9 @@ Args:
|
||||
The mayday's sender and its helpers pass. Never fails.
|
||||
show [--all] [--session <id>]: print the active silence and the
|
||||
undelivered rows, or every kept row, without delivering them.
|
||||
feedback set post|call [--session <id>]: store how outcomes of the
|
||||
session's queued operator commands reach it, in <root>/feedback.json;
|
||||
post unless set.
|
||||
feedback set post|call [--session <id>]: store the channel feedback
|
||||
send uses for the session, in <root>/feedback.json; post unless set.
|
||||
operator.py does not use it: it always calls.
|
||||
feedback show [--session <id>]: print the session's channel.
|
||||
feedback send "<text>" --to <name> ... [--sid <id>] [--session <id>]: send
|
||||
text to each name as a call when the session --sid names, else the
|
||||
@@ -395,7 +397,9 @@ def cmd_send(args: argparse.Namespace) -> int:
|
||||
cls = "call" if args.wake else "post"
|
||||
elif args.wake:
|
||||
fail("--wake only with direct; a call always wakes")
|
||||
return transmit(cls, args.to or [], args.text, args.session, [])
|
||||
if args.sid and (cls != "call" or len(args.to or []) != 1):
|
||||
fail("--sid takes a call with a single --to")
|
||||
return transmit(cls, args.to or [], args.text, args.session, [args.sid] if args.sid else [])
|
||||
|
||||
|
||||
def cmd_post(args: argparse.Namespace) -> int:
|
||||
@@ -668,6 +672,7 @@ def main() -> int:
|
||||
p.add_argument("text")
|
||||
p.add_argument("--to", action="append")
|
||||
p.add_argument("--wake", action="store_true")
|
||||
p.add_argument("--sid")
|
||||
p.add_argument("--session")
|
||||
p.set_defaults(func=cmd_send)
|
||||
p = sub.add_parser("post")
|
||||
|
||||
+155
-39
@@ -30,6 +30,8 @@ IDENTITY = {
|
||||
|
||||
|
||||
class TestOperator(unittest.TestCase):
|
||||
WAKE = "wake: SendMessage to One (session s1)"
|
||||
|
||||
def setUp(self):
|
||||
self.tmp = tempfile.TemporaryDirectory()
|
||||
self.addCleanup(self.tmp.cleanup)
|
||||
@@ -315,7 +317,7 @@ class TestOperator(unittest.TestCase):
|
||||
self.assertTrue(all(len(line) <= 60 for line in lines[start:start + 1 + len(tail)]))
|
||||
self.assertEqual(" ".join([lines[start][13:], *(line[13:] for line in tail)]), why)
|
||||
|
||||
def test_cancel_needs_a_reason_stops_the_row_and_posts_it_to_the_adding_agent(self):
|
||||
def test_cancel_needs_a_reason_stops_the_row_and_calls_the_adding_agent_with_it(self):
|
||||
work = self.base / "work"
|
||||
work.mkdir()
|
||||
self._add("keep", work, "touch kept", "stays", "manual")
|
||||
@@ -323,14 +325,13 @@ class TestOperator(unittest.TestCase):
|
||||
result = self._feed("s\nc\n \nc\nwrong repo,\tredo it\n")
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
self.assertEqual((result.stdout.count("Why cancel?"), result.stdout.count("Run it?")), (2, 3))
|
||||
self.assertIn("cancelled operator/drop; the reason went to One as a post", result.stdout)
|
||||
self.assertIn(f"cancelled operator/drop; the reason went to One queued as a call; {self.WAKE}", result.stdout)
|
||||
self.assertFalse((work / "dropped").exists())
|
||||
entry = self._register()["operator/drop"]
|
||||
self.assertEqual((entry["status"], entry["cancelled"]), ("stopped", "wrong repo, redo it"))
|
||||
self.assertEqual(self._open(), ["operator/keep"])
|
||||
posts = [json.loads(line) for line in (self.root / "news.jsonl").read_text(encoding="utf-8").splitlines()]
|
||||
self.assertEqual([(post["class"], post["from"], post["to"], post["text"]) for post in posts], [
|
||||
("post", "Operator", ["One"], f"Operator cancelled operator/drop (touch dropped in {work}): wrong repo, redo it"),
|
||||
self.assertEqual(self._messages(), [
|
||||
("call", "Operator", ["One"], f"Operator cancelled operator/drop (touch dropped in {work}): wrong repo, redo it"),
|
||||
])
|
||||
self._add("drop", work, "touch dropped", "right target", "manual")
|
||||
self.assertNotIn("cancelled", self._register()["operator/drop"])
|
||||
@@ -354,7 +355,7 @@ class TestOperator(unittest.TestCase):
|
||||
cwd=self.base, check=False,
|
||||
)
|
||||
self.assertEqual(result.returncode, 75, result.stderr)
|
||||
self.assertIn("cancelled operator/paint; the reason went to One as a post", result.stdout)
|
||||
self.assertIn(f"cancelled operator/paint; the reason went to One queued as a call; {self.WAKE}", result.stdout)
|
||||
self.assertEqual(self._register()["operator/paint"]["status"], "stopped")
|
||||
post = json.loads((self.root / "news.jsonl").read_text(encoding="utf-8"))
|
||||
self.assertNotIn("\x1b", post["text"])
|
||||
@@ -367,10 +368,10 @@ class TestOperator(unittest.TestCase):
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
self.assertIn("--no-pager --no-optional-locks log --oneline '@{u}..HEAD'", result.stdout)
|
||||
self.assertRegex(result.stdout, r"[0-9a-f]{7,} two")
|
||||
self.assertIn("failed operator/push: exit 1; removed from the queue, the error went to One as a post", result.stdout)
|
||||
self.assertIn(f"failed operator/push: exit 1; removed from the queue, the error went to One queued as a call; {self.WAKE}", result.stdout)
|
||||
self.assertEqual(self._open(), [])
|
||||
|
||||
def test_a_failed_command_leaves_the_queue_and_its_stderr_goes_to_the_adding_agent(self):
|
||||
def test_a_failed_command_leaves_the_queue_and_its_shared_stderr_waits_in_the_register(self):
|
||||
work = self.base / "work"
|
||||
work.mkdir()
|
||||
command = "echo fine; seq 1 25 >&2; printf 'last\\033[31m\\n' >&2; (exit 3)"
|
||||
@@ -380,16 +381,16 @@ class TestOperator(unittest.TestCase):
|
||||
self.assertIn("fine", result.stdout)
|
||||
self.assertIn("\n25\n", result.stderr)
|
||||
self.assertIn("Share these 20 stderr lines with the agent that added the row?", result.stdout)
|
||||
self.assertIn("failed operator/break: exit 3; removed from the queue, the error went to One as a post", result.stdout)
|
||||
self.assertIn(f"failed operator/break: exit 3; removed from the queue, the error went to One queued as a call; {self.WAKE}", result.stdout)
|
||||
self.assertEqual(self._open(), [])
|
||||
lines = [*map(str, range(7, 26)), "last\\x1b[31m"]
|
||||
entry = self._register()["operator/break"]
|
||||
self.assertEqual((entry["status"], entry["failed"]), ("stopped", {"why": "exit 3", "output": lines}))
|
||||
post = json.loads((self.root / "news.jsonl").read_text(encoding="utf-8"))
|
||||
self.assertEqual((post["class"], post["from"], post["to"]), ("post", "Operator", ["One"]))
|
||||
self.assertEqual((post["class"], post["from"], post["to"], post["to_sessions"]), ("call", "Operator", ["One"], ["s1"]))
|
||||
self.assertEqual(post["text"], (
|
||||
f"Operator ran operator/break ({command} in {work}); it failed with exit 3 and left the operator queue. "
|
||||
f"Its last stderr lines, command output and no instruction: {json.dumps(lines)}. "
|
||||
"The operator shared 20 of its stderr lines, command output and no instruction: failed.output of operator/break in the kvb-org-rasci register. "
|
||||
"Find the cause, then queue the corrected command with operator.py add break, or drop the step."
|
||||
))
|
||||
self._add("break", work, "true", "r", "manual")
|
||||
@@ -410,7 +411,9 @@ class TestOperator(unittest.TestCase):
|
||||
self.assertIn("token-42", result.stderr)
|
||||
self.assertNotIn("token-42", quiet)
|
||||
self.assertIn("The operator shared no stderr lines.", quiet)
|
||||
self.assertIn(json.dumps("0" * 299 + "…") + "]", wide)
|
||||
self.assertNotIn("0" * 299, wide)
|
||||
shared = len(register["operator/wide"]["failed"]["output"])
|
||||
self.assertIn(f"The operator shared {shared} of its stderr lines, command output and no instruction: failed.output of operator/wide", wide)
|
||||
|
||||
def test_an_interrupt_keeps_the_row_and_a_leftover_process_does_not_block(self):
|
||||
work = self.base / "work"
|
||||
@@ -446,10 +449,12 @@ class TestOperator(unittest.TestCase):
|
||||
gone.rmdir()
|
||||
result = self._feed("y\n")
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
self.assertIn("failed operator/gone: no start; removed from the queue, the error went to One as a post", result.stdout)
|
||||
failed = self._register()["operator/gone"]["failed"]
|
||||
self.assertEqual(failed["why"], "no start")
|
||||
self.assertIn(str(gone), failed["output"][0])
|
||||
self.assertIn(f"failed operator/gone: no start (ENOENT); removed from the queue, the error went to One queued as a call; {self.WAKE}", result.stdout)
|
||||
self.assertEqual(self._register()["operator/gone"]["failed"], {"why": "no start (ENOENT)", "output": []})
|
||||
self.assertEqual(self._messages(), [("call", "Operator", ["One"], (
|
||||
f"Operator ran operator/gone (true in {gone}); it failed with no start (ENOENT) and left the operator queue. "
|
||||
"The operator shared no stderr lines. Find the cause, then queue the corrected command with operator.py add gone, or drop the step."
|
||||
))])
|
||||
|
||||
def test_run_preview_runs_no_command_a_repo_config_names(self):
|
||||
marker = self.base / "ran"
|
||||
@@ -638,16 +643,13 @@ class TestOperator(unittest.TestCase):
|
||||
self.assertTrue((work / "heavy").exists())
|
||||
self.assertFalse((self.base / "heavy").exists() or (work / "other").exists())
|
||||
|
||||
def test_a_done_run_reaches_the_renamed_adder_by_its_stored_name_and_session_through_its_feedback_channel(self):
|
||||
def test_a_done_run_calls_the_renamed_adder_by_its_stored_name_and_session(self):
|
||||
work = self.base / "work"
|
||||
work.mkdir()
|
||||
self._add("go", work, "true", "r", "manual")
|
||||
self._add("later", work, "true", "r", "manual")
|
||||
self.assertEqual(self._register()["operator/go"]["sessions"], {"One": "s1"})
|
||||
self._session("s1", "Uno")
|
||||
radio = REPO_ROOT / "skills" / "kvb-org-radio" / "scripts" / "radio.py"
|
||||
chosen = subprocess.run([sys.executable, str(radio), "feedback", "set", "call"], capture_output=True, text=True, env=self.env, check=False)
|
||||
self.assertEqual(chosen.returncode, 0, chosen.stderr)
|
||||
listener = self.root / "radio-listen" / "s1.pid"
|
||||
listener.parent.mkdir()
|
||||
listener.write_text(str(os.getpid()), encoding="utf-8")
|
||||
@@ -655,12 +657,44 @@ class TestOperator(unittest.TestCase):
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
self.assertIn("done operator/go; the result went to One as a call", result.stdout)
|
||||
self.assertIn("skipped operator/later", result.stdout)
|
||||
self.assertEqual(self._messages(), [("call", "Operator", ["One"], "Operator ran operator/go: done")])
|
||||
self.assertEqual(self._messages(), [("call", "Operator", ["One"], "Operator ran operator/go: done, exit 0")])
|
||||
radio = REPO_ROOT / "skills" / "kvb-org-radio" / "scripts" / "radio.py"
|
||||
seen = subprocess.run([sys.executable, str(radio), "show"], capture_output=True, text=True, env=self.env, check=False)
|
||||
self.assertEqual([line.split(" ", 3)[3] for line in seen.stdout.splitlines()], ["Operator to One: Operator ran operator/go: done"], seen.stderr)
|
||||
self.assertEqual([line.split(" ", 3)[3] for line in seen.stdout.splitlines()], ["Operator to One: Operator ran operator/go: done, exit 0"], seen.stderr)
|
||||
|
||||
def test_an_older_row_without_a_session_reaches_its_party_name_and_an_open_check_is_reported(self):
|
||||
def test_run_calls_the_stored_session_with_every_outcome_even_when_its_channel_says_post(self):
|
||||
work = self.base / "work"
|
||||
work.mkdir()
|
||||
stale = self.base / "stale"
|
||||
stale.write_text("x", encoding="utf-8")
|
||||
radio = REPO_ROOT / "skills" / "kvb-org-radio" / "scripts" / "radio.py"
|
||||
chosen = subprocess.run([sys.executable, str(radio), "feedback", "set", "post"], capture_output=True, text=True, env=self.env, check=False)
|
||||
self.assertEqual(chosen.returncode, 0, chosen.stderr)
|
||||
self._add("open", work, "echo out-$((7 * 8)) >&2", "r", f"absent:{stale}")
|
||||
self._add("go", work, "echo out-$((6 * 7))", "r", "manual")
|
||||
self._add("drop", work, "true", "r", "manual")
|
||||
self._add("break", work, "echo out-$((8 * 9)); echo err-$((9 * 9)) >&2; (exit 3)", "r", "manual")
|
||||
self._session("s1", "Uno")
|
||||
result = self._feed("y\ny\nc\nwrong repo\ny\ny\n")
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
self.assertEqual(result.stdout.count(f"One queued as a call; {self.WAKE}"), 4, result.stdout)
|
||||
rows = [json.loads(line) for line in (self.root / "news.jsonl").read_text(encoding="utf-8").splitlines()]
|
||||
self.assertEqual([(row["class"], row["from"], row["to"], row["to_sessions"]) for row in rows], [("call", "Operator", ["One"], ["s1"])] * 4)
|
||||
still, done, dropped, broke = (row["text"] for row in rows)
|
||||
self.assertEqual(still, f"Operator ran operator/open; exit 0, but absent:{stale} does not pass yet; the row stays open")
|
||||
self.assertEqual(done, "Operator ran operator/go: done, exit 0")
|
||||
self.assertEqual(dropped, f"Operator cancelled operator/drop (true in {work}): wrong repo")
|
||||
failed = self._register()["operator/break"]["failed"]
|
||||
self.assertEqual((failed["why"], failed["output"][-1]), ("exit 3", "err-81"))
|
||||
self.assertTrue(broke.startswith("Operator ran operator/break ("), broke)
|
||||
self.assertIn(f"; it failed with exit 3 and left the operator queue. The operator shared {len(failed['output'])} of its stderr lines", broke)
|
||||
for text in (still, done, dropped, broke):
|
||||
for output in ("out-56", "out-42", "out-72", "err-81"):
|
||||
with self.subTest(text=text[:30], output=output):
|
||||
self.assertNotIn(output, text)
|
||||
self.assertEqual(subprocess.run([sys.executable, str(radio), "feedback", "show"], capture_output=True, text=True, env=self.env, check=False).stdout, "post\n")
|
||||
|
||||
def test_an_older_row_without_a_session_calls_its_party_name_and_an_open_check_is_reported(self):
|
||||
stale = self.base / "stale"
|
||||
stale.write_text("x", encoding="utf-8")
|
||||
self._add("old", self.base, "true", "r", f"absent:{stale}")
|
||||
@@ -671,8 +705,9 @@ class TestOperator(unittest.TestCase):
|
||||
result = self._feed("y\n")
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
pending = f"absent:{stale} does not pass yet; the row stays open"
|
||||
self.assertIn(f"ran operator/old, but {pending}; the result went to One as a post", result.stdout)
|
||||
self.assertEqual(self._messages(), [("post", "Operator", ["One"], f"Operator ran operator/old; exit 0, but {pending}")])
|
||||
self.assertIn(f"ran operator/old, but {pending}; the result went to One queued as a call; wake: SendMessage to One\n", result.stdout)
|
||||
self.assertEqual(self._messages(), [("call", "Operator", ["One"], f"Operator ran operator/old; exit 0, but {pending}")])
|
||||
self.assertNotIn("to_sessions", json.loads((self.root / "news.jsonl").read_text(encoding="utf-8")))
|
||||
self.assertEqual(self._open(), ["operator/old"])
|
||||
|
||||
def test_list_and_done_tell_every_holder_but_the_caller(self):
|
||||
@@ -691,16 +726,16 @@ class TestOperator(unittest.TestCase):
|
||||
self.assertEqual(self._messages(), [])
|
||||
self._add("theirs", self.base, "true", "r", f"absent:{self.base / 'gone'}")
|
||||
listed = self._as("s2", "list", "--json")
|
||||
self.assertEqual((listed.returncode, listed.stderr), (0, "operator: operator/theirs done; the result went to One as a post\n"))
|
||||
self.assertEqual((listed.returncode, listed.stderr), (0, f"operator: operator/theirs done; the result went to One queued as a call; {self.WAKE}\n"))
|
||||
self.assertEqual([row["task"] for row in json.loads(listed.stdout)], ["operator/manual", "operator/hub", "operator/self"])
|
||||
self.assertEqual(self._as("s2", "done", "manual").stdout, "done operator/manual; the result went to One as a post\n")
|
||||
self.assertEqual(self._as("s2", "done", "manual").stdout, f"done operator/manual; the result went to One queued as a call; {self.WAKE}\n")
|
||||
self.assertEqual(self._as("s2", "done", "manual").stdout, "done operator/manual\n")
|
||||
self.assertEqual(self._as(None, "done", "hub").returncode, 0)
|
||||
self.assertEqual(self._out("done", "self"), ["done operator/self"])
|
||||
self.assertEqual(self._messages(), [
|
||||
("post", "Operator", ["One"], f"operator/theirs done: its check absent:{self.base / 'gone'} passes"),
|
||||
("post", "Operator", ["One"], "operator/manual marked done by Two"),
|
||||
("post", "Operator", ["One"], "operator/hub marked done by Operator"),
|
||||
("call", "Operator", ["One"], f"operator/theirs done: check passed (absent:{self.base / 'gone'})"),
|
||||
("call", "Operator", ["One"], "operator/manual marked done by Two"),
|
||||
("call", "Operator", ["One"], "operator/hub marked done by Operator"),
|
||||
])
|
||||
self._add("flag", self.base, "true", "r", "manual")
|
||||
self.assertEqual(self._as(None, "done", "flag", "--session", "s2").returncode, 0)
|
||||
@@ -723,7 +758,7 @@ class TestOperator(unittest.TestCase):
|
||||
shown = ("--command", "false", "--dir", str(work))
|
||||
result = self._as(None, "failed", "break", "--why", "exit 3", *shown)
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
self.assertEqual(result.stdout, "failed operator/break: exit 3; removed from the queue, the error went to One as a post\n")
|
||||
self.assertEqual(result.stdout, f"failed operator/break: exit 3; removed from the queue, the error went to One queued as a call; {self.WAKE}\n")
|
||||
for args in (("--command", "true", "--dir", str(self.base)), ("--command", "echo evil", "--dir", str(work))):
|
||||
with self.subTest(args=args):
|
||||
stale = self._as(None, "failed", "moved", "--why", "exit 1", *args)
|
||||
@@ -731,7 +766,7 @@ class TestOperator(unittest.TestCase):
|
||||
register = self._register()
|
||||
self.assertEqual((register["operator/break"]["status"], register["operator/break"]["failed"]), ("stopped", {"why": "exit 3", "output": []}))
|
||||
self.assertEqual((register["operator/moved"]["status"], "failed" in register["operator/moved"]), ("queued", False))
|
||||
self.assertEqual(self._messages(), [("post", "Operator", ["One"], (
|
||||
self.assertEqual(self._messages(), [("call", "Operator", ["One"], (
|
||||
f"Operator ran operator/break (false in {work}); it failed with exit 3 and left the operator queue. "
|
||||
"The operator shared no stderr lines. Find the cause, then queue the corrected command with operator.py add break, or drop the step."
|
||||
))])
|
||||
@@ -769,14 +804,14 @@ class TestOperator(unittest.TestCase):
|
||||
self.assertEqual(ran("other", "--command", "true", "--dir", str(hub_home)), "ran operator/other; it changed or closed meanwhile and stays as it is\n")
|
||||
self.assertEqual(self._open(), ["operator/other"])
|
||||
self.assertEqual(self._messages(), [
|
||||
("call", "Operator", ["One"], "Operator ran operator/go: done"),
|
||||
("call", "Operator", ["One"], "Operator ran operator/inst: done"),
|
||||
("call", "Operator", ["One"], "Operator ran operator/go: done, exit 0"),
|
||||
("call", "Operator", ["One"], "Operator ran operator/inst: done, exit 0"),
|
||||
])
|
||||
rows = [json.loads(line) for line in (self.root / "news.jsonl").read_text(encoding="utf-8").splitlines()]
|
||||
self.assertEqual([row["to_sessions"] for row in rows], [["s1"], ["s1"]])
|
||||
self._session("s2", "One")
|
||||
self._session("s3", "Uno")
|
||||
expected = ["Operator to One: Operator ran operator/go: done", "Operator to One: Operator ran operator/inst: done"]
|
||||
expected = ["Operator to One: Operator ran operator/go: done, exit 0", "Operator to One: Operator ran operator/inst: done, exit 0"]
|
||||
for sid, seen in (("s1", expected), ("s2", expected), ("s3", [])):
|
||||
with self.subTest(sid=sid):
|
||||
read = subprocess.run([sys.executable, str(radio), "show"], capture_output=True, text=True, env={**self.env, "CLAUDE_CODE_SESSION_ID": sid}, check=False)
|
||||
@@ -797,6 +832,50 @@ class TestOperator(unittest.TestCase):
|
||||
with self.subTest(args=args):
|
||||
self.assertEqual(self._as(None, *args).returncode, 2)
|
||||
|
||||
def test_the_hub_runner_calls_the_stored_session_with_ran_and_failed_even_when_its_channel_says_post(self):
|
||||
radio = REPO_ROOT / "skills" / "kvb-org-radio" / "scripts" / "radio.py"
|
||||
chosen = subprocess.run([sys.executable, str(radio), "feedback", "set", "post"], capture_output=True, text=True, env=self.env, check=False)
|
||||
self.assertEqual(chosen.returncode, 0, chosen.stderr)
|
||||
self._add("go", self.base, "true", "r", "manual")
|
||||
self._add("break", self.base, "false", "r", "manual")
|
||||
hub_home = self.base / "hub-home"
|
||||
hub_home.mkdir()
|
||||
runner = (
|
||||
"import json, sys, types\n"
|
||||
"from pathlib import Path\n"
|
||||
"sys.path.insert(0, sys.argv[1])\n"
|
||||
"from kvb_orchestrator.jobs import Jobs\n"
|
||||
"from kvb_orchestrator.skill_scripts import Scripts\n"
|
||||
"hub = types.SimpleNamespace(scripts=Scripts(Path(sys.argv[2]), Path(sys.argv[3]), Path(sys.argv[4])))\n"
|
||||
"print(json.dumps([Jobs.close_row(hub, job, status, code) for job, status, code in json.loads(sys.argv[5])]))\n"
|
||||
)
|
||||
jobs = [
|
||||
[{"task": "operator/go", "command": "true", "directory": str(self.base)}, "done", 0],
|
||||
[{"task": "operator/break", "command": "false", "directory": str(self.base)}, "failed", 1],
|
||||
]
|
||||
result = subprocess.run(
|
||||
[sys.executable, "-c", runner, str(REPO_ROOT / "orchestrator"), str(REPO_ROOT / "skills"), str(self.root), str(hub_home), json.dumps(jobs)],
|
||||
capture_output=True, text=True, env={"PATH": "/usr/bin:/bin", "PYTHONDONTWRITEBYTECODE": "1"}, check=False,
|
||||
)
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
runs = json.loads(result.stdout)
|
||||
self.assertEqual([[(run["code"], run["stderr"]) for run in job] for job in runs], [[(0, "")], [(0, "")]])
|
||||
self.assertEqual([job[0]["stdout"] for job in runs], [
|
||||
f"done operator/go; the result went to One queued as a call; {self.WAKE}\n",
|
||||
f"failed operator/break: exit 1; removed from the queue, the error went to One queued as a call; {self.WAKE}\n",
|
||||
])
|
||||
rows = [json.loads(line) for line in (self.root / "news.jsonl").read_text(encoding="utf-8").splitlines()]
|
||||
self.assertEqual([(row["class"], row["from"], row["to"], row["to_sessions"]) for row in rows], [("call", "Operator", ["One"], ["s1"])] * 2)
|
||||
self.assertEqual([row["text"] for row in rows], [
|
||||
"Operator ran operator/go: done, exit 0",
|
||||
(
|
||||
f"Operator ran operator/break (false in {self.base}); it failed with exit 1 and left the operator queue. "
|
||||
"The operator shared no stderr lines. Find the cause, then queue the corrected command with operator.py add break, or drop the step."
|
||||
),
|
||||
])
|
||||
register = self._register()
|
||||
self.assertEqual((register["operator/go"]["status"], register["operator/break"]["status"]), ("done", "stopped"))
|
||||
|
||||
def test_done_leaves_out_the_caller_by_session_id_and_by_name_each_on_its_own(self):
|
||||
self._add("by-sid", self.base, "true", "r", "manual")
|
||||
self._add("by-name", self.base, "true", "r", "manual")
|
||||
@@ -811,13 +890,50 @@ class TestOperator(unittest.TestCase):
|
||||
self.assertEqual(self._out("done", "by-name"), ["done operator/by-name"])
|
||||
self.assertEqual(self._messages(), [])
|
||||
|
||||
def test_a_row_closed_outside_run_calls_its_initiator_once_even_when_its_channel_says_post(self):
|
||||
radio = REPO_ROOT / "skills" / "kvb-org-radio" / "scripts" / "radio.py"
|
||||
chosen = subprocess.run([sys.executable, str(radio), "feedback", "set", "post"], capture_output=True, text=True, env=self.env, check=False)
|
||||
self.assertEqual(chosen.returncode, 0, chosen.stderr)
|
||||
marks = {slug: self.base / slug for slug in ("swept", "legacy", "later")}
|
||||
for slug, mark in marks.items():
|
||||
mark.write_text("x", encoding="utf-8")
|
||||
self._add(slug, self.base, "true", "r", f"absent:{mark}")
|
||||
self._add("manual", self.base, "true", "r", "manual")
|
||||
register = self._register()
|
||||
register["operator/legacy"].pop("sessions")
|
||||
(self.root / "rasci.json").write_text(json.dumps(register), encoding="utf-8")
|
||||
self._session("s1", "Uno")
|
||||
marks["swept"].unlink()
|
||||
marks["legacy"].unlink()
|
||||
listed = self._as(None, "list")
|
||||
self.assertEqual(listed.stderr, (
|
||||
"operator: operator/legacy done; the result went to One queued as a call; wake: SendMessage to One\n"
|
||||
f"operator: operator/swept done; the result went to One queued as a call; {self.WAKE}\n"
|
||||
))
|
||||
self.assertEqual(self._as(None, "done", "swept").stdout, "done operator/swept\n")
|
||||
self.assertEqual(self._as(None, "done", "manual").stdout, f"done operator/manual; the result went to One queued as a call; {self.WAKE}\n")
|
||||
self.assertEqual(self._as(None, "done", "manual").stdout, "done operator/manual\n")
|
||||
marks["later"].unlink()
|
||||
ran = self._feed("q\n")
|
||||
self.assertEqual(ran.returncode, 0, ran.stderr)
|
||||
self.assertIn("operator: nothing to run", ran.stdout)
|
||||
self.assertEqual(self._as(None, "done", "later").stdout, "done operator/later\n")
|
||||
self.assertEqual(self._as(None, "list").stdout, "operator: nothing open\n")
|
||||
rows = [json.loads(line) for line in (self.root / "news.jsonl").read_text(encoding="utf-8").splitlines()]
|
||||
self.assertEqual([(row["class"], row["from"], row["to"], row.get("to_sessions"), row["text"]) for row in rows], [
|
||||
("call", "Operator", ["One"], None, f"operator/legacy done: check passed (absent:{marks['legacy']})"),
|
||||
("call", "Operator", ["One"], ["s1"], f"operator/swept done: check passed (absent:{marks['swept']})"),
|
||||
("call", "Operator", ["One"], ["s1"], "operator/manual marked done by Operator"),
|
||||
("call", "Operator", ["One"], ["s1"], f"operator/later done: check passed (absent:{marks['later']})"),
|
||||
])
|
||||
|
||||
def test_done_by_the_successor_holding_the_stored_name_reaches_the_renamed_adder_by_its_session_only(self):
|
||||
self._add("go", self.base, "true", "r", "manual")
|
||||
self._session("s1", "Uno")
|
||||
self._session("s2", "One")
|
||||
done = self._as("s2", "done", "go")
|
||||
self.assertEqual((done.returncode, done.stdout), (0, "done operator/go; the result went to s1 as a post\n"), done.stderr)
|
||||
self.assertEqual(self._messages(), [("post", "Operator", ["s1"], "operator/go marked done by One")])
|
||||
self.assertEqual((done.returncode, done.stdout), (0, "done operator/go; the result went to s1 queued as a call; wake: SendMessage to s1 (session s1)\n"), done.stderr)
|
||||
self.assertEqual(self._messages(), [("call", "Operator", ["s1"], "operator/go marked done by One")])
|
||||
radio = REPO_ROOT / "skills" / "kvb-org-radio" / "scripts" / "radio.py"
|
||||
for sid, seen in (("s1", 1), ("s2", 0)):
|
||||
with self.subTest(sid=sid):
|
||||
@@ -838,11 +954,11 @@ class TestOperator(unittest.TestCase):
|
||||
shown = ("--command", "true", "--dir", str(self.base))
|
||||
for slug in ("stopped", "running"):
|
||||
with self.subTest(slug=slug):
|
||||
self.assertEqual(self._as(None, "ran", slug, *shown).stdout, f"done operator/{slug}; the result went to One as a post\n")
|
||||
self.assertEqual(self._as(None, "ran", slug, *shown).stdout, f"done operator/{slug}; the result went to One queued as a call; {self.WAKE}\n")
|
||||
entry = self._register()[f"operator/{slug}"]
|
||||
self.assertEqual((entry["status"], "failed" in entry, "cancelled" in entry), ("done", False, False))
|
||||
self.assertEqual(self._as(None, "ran", "done", *shown).stdout, "ran operator/done; it changed or closed meanwhile and stays as it is\n")
|
||||
self.assertEqual([message[3] for message in self._messages()], ["Operator ran operator/stopped: done", "Operator ran operator/running: done"])
|
||||
self.assertEqual([message[3] for message in self._messages()], ["Operator ran operator/stopped: done, exit 0", "Operator ran operator/running: done, exit 0"])
|
||||
|
||||
def test_done_drops_the_stale_failure_of_a_stopped_row_like_ran(self):
|
||||
self._add("go", self.base, "false", "r", "manual")
|
||||
|
||||
@@ -752,6 +752,23 @@ class TestRadio(unittest.TestCase):
|
||||
self.assertEqual(self._send("s1", "feedback", "send", "ran y", "--to", "Two", "--sid", "s9"), ["sent call to Two"])
|
||||
self.assertEqual(self._send("s1", "feedback", "send", "ran z", "--to", "Nine", "--sid", "s9"), ["sent call to Nine", "wake: SendMessage to Nine (session s9)"])
|
||||
|
||||
def test_send_pins_a_call_to_its_session_whatever_its_feedback_channel_and_only_a_call(self):
|
||||
self._send("s2", "feedback", "set", "post")
|
||||
self.assertEqual(self._send("s1", "send", "call", "ran x", "--to", "Two", "--sid", "s2"), ["sent call to Two", "wake: SendMessage to Two (session s2)"])
|
||||
self.assertEqual(self._send("s1", "send", "direct", "ran y", "--to", "Two", "--wake", "--sid", "s2"), ["sent call to Two", "wake: SendMessage to Two (session s2)"])
|
||||
for args in (
|
||||
("send", "call", "t", "--to", "Two", "--to", "Three", "--sid", "s2"),
|
||||
("send", "direct", "t", "--to", "Two", "--sid", "s2"),
|
||||
("send", "broadcast", "t", "--sid", "s2"),
|
||||
):
|
||||
with self.subTest(args=args):
|
||||
self.assertEqual(self._cli("s1", *args).returncode, 2)
|
||||
self.assertEqual([(row["class"], row["to"], row["to_sessions"]) for row in self._rows()], [("call", ["Two"], ["s2"])] * 2)
|
||||
(self.home / ".claude" / "sessions" / "s2.json").write_text(json.dumps({"sessionId": "s2", "name": "Deux"}), encoding="utf-8")
|
||||
self.assertEqual(self._prompt("s2"), ["CALL One to Two: ran x", "CALL One to Two: ran y"])
|
||||
self._send("s1", "send", "call", "plain", "--to", "Two")
|
||||
self.assertNotIn("to_sessions", self._rows()[-1])
|
||||
|
||||
def test_feedback_send_without_a_session_takes_the_channel_the_name_set(self):
|
||||
self._send("s2", "feedback", "set", "call")
|
||||
self._send(None, "feedback", "set", "call", "--session", "codex-1")
|
||||
|
||||
Reference in new issue
Block a user