ai_co_discuss 0.3.72 → 0.3.74

package/README.md

@@ -115,7 +115,7 @@ Details: [Architecture](docs/en/architecture.md) · [Setup](docs/en/runner.md)
 The site can be self-hosted on **Cloudflare Pages + D1** or **Docker**; agents and the runner still run on your own machine. A Docker site keeps its own rooms; the Cloudflare site keeps none and shows the rooms on your paired computer to paired devices through an encrypted relay. See [Deployment](docs/en/deployment.md).
 
 > [!WARNING]
-> The site does not yet provide user login or read-access isolation. Anyone who can reach the site can read its rooms. Read the [security policy](.github/SECURITY.md) before exposing it publicly.
+> Sites that store rooms (local or Docker) do not yet provide user login or read-access isolation: anyone who can reach such a site can read its rooms. The Cloudflare site stores no rooms and shows them only to devices paired at your computer. Read the [security policy](.github/SECURITY.md) before exposing a site publicly.
 
 ## Documentation
 

package/README.zh-CN.md

@@ -109,7 +109,7 @@ flowchart LR
 网站支持自托管于 **Cloudflare Pages + D1** 或 **Docker**；AI 与接入服务仍在你的电脑运行。Docker 站点自己保存房间；Cloudflare 站点不保存房间，已配对的设备经加密中转看到电脑上的房间。见 [部署指南](docs/deployment.md)。
 
 > [!WARNING]
-> 网站暂无用户登录与读取权限隔离，能访问站点的人即可阅读其中的房间。公开部署前请阅读 [安全说明](.github/SECURITY.md)。
+> 保存房间的站点（本机或 Docker）暂无用户登录与读取权限隔离，能访问该站点的人即可阅读其中的房间。Cloudflare 站点不保存房间，只向在电脑前配对过的设备显示。公开部署前请阅读 [安全说明](.github/SECURITY.md)。
 
 ## 文档
 

package/backend/free_room.py

@@ -1885,6 +1885,9 @@ def inbox(connection, room_id, token):
         # The runner compares this with its adapter's effect and reports a change.
         reported = connection.execute("SELECT rewind FROM member_capabilities WHERE member_id=?", (row["id"],)).fetchone()
         member_view["rewind"] = reported[0] if reported else ""
+        # Private chat lines the runner still has to run in this member's session (backend/private_chat.py).
+        member_view["chats"] = [dict(item) for item in connection.execute(
+            "SELECT id,text,status FROM private_chats WHERE member_id=? AND status IN ('pending','running') ORDER BY id", (row["id"],))]
         pending = [{**request, **review_request_context(connection, request), **sequence_request_context(connection, request)} for request in pending]
         (members if row["access"] == "runner" else observers).append({**member_view, "pending": pending})
     # Pending interjections ride along so the runner hands them to the running software at its next check.

package/backend/private_chat.py

@@ -0,0 +1,108 @@
+"""
+Private chat: the owner talks to one room member directly, in the member's own session, outside the room's messages.
+
+Each row of `private_chats` is one thing the owner said and the member's reply. While the member works on a room
+execution that takes interjections, a new line goes in as an interjection of that execution; otherwise it waits until
+the member is idle and the runner runs it as a turn of its own, taking the reply from the software's output. Only the
+owner reads or writes chats; the runner, which holds the owner credential, reports their progress.
+"""
+import time
+
+from .free_room import ACTIVE, add_interjection
+from .runtime import begin_write, require_owner
+
+MAX_CHAT_LENGTH = 4000
+MAX_REPLY_LENGTH = 20000
+MAX_REASON_LENGTH = 500
+SHOWN_CHATS = 200
+# Interjections made from a chat line carry its submission id under this prefix, so the two are found together.
+INTERJECTION_PREFIX = "chat-"
+# Runner reports and the owner's stop, each with the states it may leave.
+TRANSITIONS = {"start": ("pending", "running"), "steered": ("pending", "interjected"), "reply": ("running", "answered"),
+               "fail": (("pending", "running"), "failed"), "stop": (("pending", "running"), "stopped")}
+
+
+def chat_member(connection, room_id, member_id):
+    """The active member the runner wakes; a manual member is reached only in its own window."""
+    member = connection.execute("SELECT * FROM room_members WHERE room_id=? AND id=? AND status='active'", (room_id, member_id)).fetchone()
+    if not member:
+        raise LookupError("成员不存在或已离开")
+    if member["access"] != "runner":
+        raise FileExistsError("这位成员是手动接入的，只能在它自己的窗口里对话")
+    return member
+
+
+def public_chat(connection, row):
+    """One chat line as the page shows it; a line passed in as an interjection shows how that went."""
+    chat = {key: row[key] for key in ("id", "member_id", "text", "status", "reply", "reason", "execution_id", "created_at", "updated_at")}
+    if row["status"] == "interjected":
+        interjection = connection.execute("""SELECT i.status,i.reason,e.status AS execution_status FROM execution_interjections i
+            JOIN member_executions e ON e.id=i.execution_id WHERE i.room_id=? AND i.submission_id=?""",
+                                          (row["room_id"], INTERJECTION_PREFIX + row["submission_id"])).fetchone()
+        if interjection:
+            ended = interjection["status"] == "pending" and interjection["execution_status"] not in ACTIVE
+            chat["interjection"] = "failed" if ended else interjection["status"]
+            chat["reason"] = "送达前那次执行已结束" if ended else interjection["reason"]
+    return chat
+
+
+def member_chat(connection, room_id, member_id, token, payload=None):
+    """Read one member's private chat, or add the owner's next line to it."""
+    require_owner(connection, room_id, token)
+    if payload is None:
+        chat_member(connection, room_id, member_id)
+        rows = connection.execute("SELECT * FROM (SELECT * FROM private_chats WHERE room_id=? AND member_id=? ORDER BY id DESC LIMIT ?) ORDER BY id",
+                                  (room_id, member_id, SHOWN_CHATS)).fetchall()
+        return {"member_id": member_id, "chats": [public_chat(connection, row) for row in rows]}
+    begin_write(connection)
+    member = chat_member(connection, room_id, member_id)
+    text, submission_id = payload.get("text"), payload.get("submission_id")
+    if not isinstance(text, str) or not 0 < len(text.strip()) <= MAX_CHAT_LENGTH:
+        raise ValueError(f"私聊内容须为 1–{MAX_CHAT_LENGTH} 字")
+    if not isinstance(submission_id, str) or not 0 < len(submission_id) <= 100:
+        raise ValueError("私聊须带 submission_id；重试沿用原编号")
+    earlier = connection.execute("SELECT * FROM private_chats WHERE room_id=? AND submission_id=?", (room_id, submission_id)).fetchone()
+    if earlier:
+        if earlier["member_id"] != member_id or earlier["text"] != text:
+            raise FileExistsError("submission_id 已用于另一句私聊")
+        return public_chat(connection, earlier)
+    now = int(time.time())
+    # A room execution that takes interjections hears it now; one that cannot waits, like a turn already running.
+    execution = connection.execute("""SELECT e.* FROM member_executions e JOIN execution_capabilities c ON c.execution_id=e.id
+        WHERE e.member_id=? AND e.status IN ('dispatched','started') AND c.steer=1 ORDER BY e.id DESC LIMIT 1""", (member["id"],)).fetchone()
+    status, execution_id = "pending", None
+    if execution:
+        add_interjection(connection, room_id, execution, {"text": text, "submission_id": INTERJECTION_PREFIX + submission_id}, now)
+        status, execution_id = "interjected", execution["id"]
+    cursor = connection.execute("""INSERT INTO private_chats (room_id,member_id,submission_id,text,status,execution_id,created_at,updated_at)
+        VALUES (?,?,?,?,?,?,?,?)""", (room_id, member_id, submission_id, text, status, execution_id, now, now))
+    return public_chat(connection, connection.execute("SELECT * FROM private_chats WHERE id=?", (cursor.lastrowid,)).fetchone())
+
+
+def chat_action(connection, room_id, chat_id, token, payload):
+    """The runner's progress on one chat line (start, steered, reply, fail), or the owner's stop."""
+    require_owner(connection, room_id, token)
+    begin_write(connection)
+    action = payload.get("action")
+    if action not in TRANSITIONS:
+        raise ValueError(f"action 须为 {'、'.join(TRANSITIONS)}")
+    row = connection.execute("SELECT * FROM private_chats WHERE room_id=? AND id=?", (room_id, chat_id)).fetchone()
+    if not row:
+        raise LookupError("私聊不存在")
+    allowed, target = TRANSITIONS[action]
+    if row["status"] == target:
+        return public_chat(connection, row)
+    if row["status"] not in (allowed if isinstance(allowed, tuple) else (allowed,)):
+        raise FileExistsError(f"这句私聊当前为 {row['status']}，不能 {action}")
+    reply, reason = payload.get("text", ""), payload.get("reason", "")
+    if not isinstance(reply, str) or len(reply) > MAX_REPLY_LENGTH or not isinstance(reason, str) or len(reason) > MAX_REASON_LENGTH:
+        raise ValueError(f"text 最多 {MAX_REPLY_LENGTH} 字，reason 最多 {MAX_REASON_LENGTH} 字")
+    connection.execute("UPDATE private_chats SET status=?,reply=?,reason=?,updated_at=? WHERE id=?",
+                       (target, reply if action == "reply" else row["reply"], reason, int(time.time()), chat_id))
+    return public_chat(connection, connection.execute("SELECT * FROM private_chats WHERE id=?", (chat_id,)).fetchone())
+
+
+def open_chats(connection, member_id):
+    """The lines the runner still has to run or is running for one member, in order."""
+    return [dict(row) for row in connection.execute(
+        "SELECT id,text,status FROM private_chats WHERE member_id=? AND status IN ('pending','running') ORDER BY id", (member_id,))]

package/backend/schema.sql

@@ -461,6 +461,26 @@ CREATE TABLE IF NOT EXISTS execution_interjections (
     UNIQUE(room_id,submission_id)
 );
 CREATE INDEX IF NOT EXISTS execution_interjections_execution ON execution_interjections(execution_id);
+-- The owner's private chat with one room member: each row is one thing the owner said and the member's reply, outside
+-- the room's messages, so other members never read it. It runs in the member's own session: while the member works on
+-- a room execution that takes interjections it goes in as one (`interjected`, execution_id); otherwise it waits
+-- (`pending`) until the member is idle and the runner runs it as its own turn (`running`), taking the reply from the
+-- software's own output (`answered`). The owner may stop it (`stopped`); the runner reports `failed` with a reason.
+CREATE TABLE IF NOT EXISTS private_chats (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    room_id TEXT NOT NULL REFERENCES rooms(id) ON DELETE CASCADE,
+    member_id INTEGER NOT NULL REFERENCES room_members(id) ON DELETE CASCADE,
+    submission_id TEXT NOT NULL,
+    text TEXT NOT NULL,
+    status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending','running','answered','failed','stopped','interjected')),
+    reply TEXT NOT NULL DEFAULT '',
+    reason TEXT NOT NULL DEFAULT '',
+    execution_id INTEGER,
+    created_at INTEGER NOT NULL,
+    updated_at INTEGER NOT NULL,
+    UNIQUE(room_id,submission_id)
+);
+CREATE INDEX IF NOT EXISTS private_chats_member ON private_chats(member_id,id);
 -- What a rewind does to each runner member's session, as its adapter reported: cut by the runner, rebuilt each time
 -- (fresh), or kept as it is. A member without a report is kept; manual and online members are always kept.
 CREATE TABLE IF NOT EXISTS member_capabilities (
@@ -1131,6 +1151,19 @@ BEGIN
     INSERT INTO room_revisions (room_id,revision) SELECT NEW.room_id,(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
         WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id=NEW.room_id);
 END;
+CREATE TRIGGER IF NOT EXISTS revision_chat_insert AFTER INSERT ON private_chats
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id=NEW.room_id;
+    INSERT INTO room_revisions (room_id,revision) SELECT NEW.room_id,(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id=NEW.room_id);
+END;
+CREATE TRIGGER IF NOT EXISTS revision_chat_update AFTER UPDATE OF status ON private_chats
+WHEN OLD.status IS NOT NEW.status
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id=NEW.room_id;
+    INSERT INTO room_revisions (room_id,revision) SELECT NEW.room_id,(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id=NEW.room_id);
+END;
 CREATE TRIGGER IF NOT EXISTS revision_interjection_insert AFTER INSERT ON execution_interjections
 BEGIN
     UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id=NEW.room_id;