ymai-codeflow 0.0.0-stage → 0.3.30

package/runtime/providers/text_cli.py

@@ -0,0 +1,106 @@
+"""文本型 CLI provider:Gemini / Codex / Cursor CLI。
+
+与 claude 的 stream-json 协议不同,这三家 CLI 以纯文本 stdout 返回结果:
+  gemini  gemini -p "<prompt>"
+  codex   codex exec "<prompt>"
+  cursor  cursor-agent -p "<prompt>"
+stdout 全文作为该步骤摘要;exit 0 即成功。凭据走各家 CLI 的环境变量/本机配置
+(GEMINI_API_KEY / OPENAI_API_KEY 等),不经 runtime 转手;HOME 保持调用方环境,
+允许读本机已有的 CLI 登录态。
+"""
+from __future__ import annotations
+
+import os
+import signal
+import subprocess
+import threading
+import time
+from pathlib import Path
+
+from .base import RunContext, RunResult, RuntimeEvent, SdlcStep
+
+KIND_DEFAULT_CMD = {"gemini": "gemini", "codex": "codex", "cursor": "cursor-agent"}
+
+
+class TextCliProvider:
+    name = "text-cli"
+
+    def __init__(self, kind: str, cli_binary: str, timeout_sec: int = 1800):
+        if kind not in KIND_DEFAULT_CMD:
+            raise ValueError(f"unknown text-cli kind: {kind}")
+        self.kind = kind
+        self.name = kind
+        self.cli_binary = cli_binary
+        self.timeout_sec = timeout_sec
+
+    def _argv(self, prompt: str) -> list[str]:
+        if self.kind in ("gemini", "cursor"):
+            return [self.cli_binary, "-p", prompt]
+        return [self.cli_binary, "exec", prompt]  # codex
+
+    def prepare(self, capsule, workdir: Path) -> None:
+        (workdir / "deliverables").mkdir(parents=True, exist_ok=True)
+
+    def _prompt(self, step: SdlcStep, capsule) -> str:
+        parts = [
+            f"# 工单\n{capsule.workitem_md}",
+            f"# 当前步骤({step.step_id},顺序 {step.step_order}):{step.name}",
+            f"目标:{step.goal}",
+        ]
+        if step.deliverables:
+            parts.append("要求的产物:" + ", ".join(step.deliverables))
+        if step.done_gate:
+            parts.append(f"完成门:{step.done_gate}")
+        parts.append("完成后把产物写入 deliverables/ 目录。")
+        return "\n\n".join(parts)
+
+    def run(self, step: SdlcStep, ctx: RunContext) -> RunResult:
+        started = RuntimeEvent("step.started", step.step_order, step.step_id, step.name)
+        if ctx.emit_event:
+            ctx.emit_event(started)
+
+        argv = self._argv(self._prompt(step, ctx.capsule))
+        env = dict(os.environ)
+        # start_new_session:超时 killpg 不连坐 daemon(同 claude provider,DEF-009)
+        proc = subprocess.Popen(argv, cwd=str(ctx.workdir.root), env=env,
+                                stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+                                start_new_session=True)
+
+        def _kill_tree():
+            time.sleep(self.timeout_sec)
+            if proc.poll() is None:
+                try:
+                    os.killpg(os.getpgid(proc.pid), signal.SIGKILL)
+                except (ProcessLookupError, PermissionError):
+                    proc.kill()
+
+        watcher = threading.Thread(target=_kill_tree, daemon=True)
+        watcher.start()
+        timed_out = False
+        try:
+            out, err = proc.communicate(timeout=self.timeout_sec + 5)
+        except subprocess.TimeoutExpired:
+            timed_out = True
+            out, err = proc.communicate()
+        watcher.join(timeout=1)
+
+        text = (out or b"").decode("utf-8", "replace").strip()
+        if timed_out:
+            state, summary, error = "timed_out", "", f"{self.kind} timeout after {self.timeout_sec}s"
+        elif proc.returncode == 0:
+            state, summary, error = "completed", text or f"step {step.step_id} completed", ""
+        else:
+            state = "failed"
+            summary = f"{self.kind} exited with {proc.returncode}"
+            error = (err or b"").decode("utf-8", "replace")[-2000:] or summary
+
+        artifacts = sorted((ctx.workdir.root / "deliverables").glob("*"))
+        completed = RuntimeEvent("step.completed", step.step_order, step.step_id, step.name,
+                                 message=state)
+        if ctx.emit_event:
+            ctx.emit_event(completed)
+        return RunResult(state=state, summary=summary[:2000], error=error,
+                         events=[started, completed], artifacts=artifacts, session_ref=None)
+
+    def cleanup(self, run_record: dict) -> None:
+        pass

package/runtime/store.py

@@ -0,0 +1,126 @@
+"""SQLite-backed local state (runs/events/outbox/terminal)."""
+from __future__ import annotations
+
+import json
+import sqlite3
+import threading
+import time
+from pathlib import Path
+
+_SCHEMA = """
+CREATE TABLE IF NOT EXISTS runs (
+  dispatch_id INTEGER PRIMARY KEY,
+  tenant_id TEXT NOT NULL, workitem_id TEXT NOT NULL, attempt INTEGER NOT NULL,
+  state TEXT NOT NULL, capsule_dir TEXT, provider TEXT NOT NULL,
+  session_ref TEXT, error TEXT,
+  created_at TEXT NOT NULL, updated_at TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS events (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  dispatch_id INTEGER NOT NULL, ts TEXT NOT NULL, type TEXT NOT NULL,
+  step_order INTEGER, step_id TEXT, step_name TEXT, payload TEXT,
+  FOREIGN KEY (dispatch_id) REFERENCES runs(dispatch_id)
+);
+CREATE INDEX IF NOT EXISTS idx_events_dispatch ON events(dispatch_id, id);
+CREATE TABLE IF NOT EXISTS outbox (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  dispatch_id INTEGER, frame_type TEXT NOT NULL, payload TEXT NOT NULL,
+  state TEXT NOT NULL DEFAULT 'pending', created_at TEXT NOT NULL, sent_at TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_outbox_state ON outbox(state, id);
+CREATE TABLE IF NOT EXISTS terminal (
+  dispatch_id INTEGER PRIMARY KEY, success INTEGER NOT NULL, finished_at TEXT NOT NULL
+);
+"""
+
+ACTIVE_STATES = ("received", "preparing", "running")
+
+
+def _now() -> str:
+    return time.strftime("%Y-%m-%dT%H:%M:%S%z")
+
+
+class StateStore:
+    def __init__(self, path: str):
+        self.path = path
+        Path(path).parent.mkdir(parents=True, exist_ok=True)
+        self._lock = threading.Lock()
+        self.conn = sqlite3.connect(path, check_same_thread=False)
+        self.conn.row_factory = sqlite3.Row
+        self.conn.execute("PRAGMA journal_mode=WAL")
+        self.conn.executescript(_SCHEMA)
+        self.conn.commit()
+
+    # ---- runs ----
+    def create_run(self, dispatch: dict, provider: str) -> bool:
+        """Insert run row; returns False if dispatch already tracked."""
+        try:
+            with self._lock, self.conn:
+                self.conn.execute(
+                    "INSERT INTO runs (dispatch_id, tenant_id, workitem_id, attempt, state, provider, created_at, updated_at)"
+                    " VALUES (?,?,?,?,?,?,?,?)",
+                    (int(dispatch["dispatchId"]), str(dispatch.get("tenantId")), str(dispatch.get("workitemId")),
+                     int(dispatch.get("attempt", 1)), "received", provider, _now(), _now()))
+            return True
+        except sqlite3.IntegrityError:
+            return False
+
+    def run_state(self, dispatch_id: int) -> str | None:
+        row = self.conn.execute("SELECT state FROM runs WHERE dispatch_id=?", (dispatch_id,)).fetchone()
+        return row[0] if row else None
+
+    def update_run(self, dispatch_id: int, **fields) -> None:
+        if not fields:
+            return
+        sets = ", ".join(f"{k}=?" for k in fields)
+        vals = list(fields.values()) + [_now(), dispatch_id]
+        with self._lock, self.conn:
+            self.conn.execute(f"UPDATE runs SET {sets}, updated_at=? WHERE dispatch_id=?", vals)
+
+    def set_session(self, dispatch_id: int, session_ref: str) -> None:
+        self.update_run(dispatch_id, session_ref=session_ref)
+
+    def get_session(self, dispatch_id: int) -> str | None:
+        row = self.conn.execute("SELECT session_ref FROM runs WHERE dispatch_id=?", (dispatch_id,)).fetchone()
+        return row[0] if row else None
+
+    def active_runs(self) -> list[sqlite3.Row]:
+        q = ",".join("?" * len(ACTIVE_STATES))
+        return self.conn.execute(f"SELECT * FROM runs WHERE state IN ({q})", ACTIVE_STATES).fetchall()
+
+    # ---- events ----
+    def add_event(self, dispatch_id: int, type_: str, *, step_order=None, step_id=None,
+                  step_name=None, payload: dict | None = None) -> None:
+        with self._lock, self.conn:
+            self.conn.execute(
+                "INSERT INTO events (dispatch_id, ts, type, step_order, step_id, step_name, payload) VALUES (?,?,?,?,?,?,?)",
+                (dispatch_id, _now(), type_, step_order, step_id, step_name,
+                 json.dumps(payload, ensure_ascii=False) if payload else None))
+
+    # ---- outbox ----
+    def enqueue_frame(self, frame_type: str, payload: dict, dispatch_id: int | None = None) -> int:
+        with self._lock, self.conn:
+            cur = self.conn.execute(
+                "INSERT INTO outbox (dispatch_id, frame_type, payload, created_at) VALUES (?,?,?,?)",
+                (dispatch_id, frame_type, json.dumps(payload, ensure_ascii=False), _now()))
+            return cur.lastrowid  # type: ignore[return-value]
+
+    def pending_frames(self) -> list[sqlite3.Row]:
+        return self.conn.execute(
+            "SELECT id, dispatch_id, frame_type, payload FROM outbox WHERE state='pending' ORDER BY id").fetchall()
+
+    def mark_sent(self, outbox_id: int) -> None:
+        with self._lock, self.conn:
+            self.conn.execute("UPDATE outbox SET state='sent', sent_at=? WHERE id=?", (_now(), outbox_id))
+
+    # ---- terminal / idempotency ----
+    def is_terminal(self, dispatch_id: int) -> bool:
+        row = self.conn.execute("SELECT 1 FROM terminal WHERE dispatch_id=?", (dispatch_id,)).fetchone()
+        return row is not None
+
+    def mark_terminal(self, dispatch_id: int, success: bool) -> None:
+        with self._lock, self.conn:
+            self.conn.execute("INSERT OR REPLACE INTO terminal (dispatch_id, success, finished_at) VALUES (?,?,?)",
+                              (dispatch_id, 1 if success else 0, _now()))
+            self.conn.execute("UPDATE runs SET state=?, updated_at=? WHERE dispatch_id=?",
+                              ("completed" if success else "failed", _now(), dispatch_id))

package/runtime/wsclient.py

@@ -0,0 +1,174 @@
+"""Minimal RFC6455 WebSocket client (text frames), stdlib only.
+
+Implements the subset needed by the protocol: client->server masked text frames,
+server->client unmasked text/binary/ping/close, client-initiated close.
+"""
+from __future__ import annotations
+
+import base64
+import hashlib
+import json
+import os
+import socket
+import ssl
+import struct
+import threading
+
+_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
+
+
+class WsClosed(Exception):
+    pass
+
+
+class WsIdleTimeout(WsClosed):
+    """Read timeout with no inbound frames; the connection may still be alive."""
+    pass
+
+
+class WsClient:
+    def __init__(self, host: str, port: int, path: str, use_tls: bool = False,
+                 extra_headers: dict | None = None, timeout: float = 60.0):
+        self.host, self.port, self.path = host, port, path
+        self.use_tls = use_tls
+        self.extra_headers = extra_headers or {}
+        self.timeout = timeout
+        self.sock: socket.socket | None = None
+        self._send_lock = threading.Lock()
+        self._leftover = b""
+
+    # ---- handshake -------------------------------------------------------
+    def connect(self) -> None:
+        raw = socket.create_connection((self.host, self.port), timeout=self.timeout)
+        if self.use_tls:
+            ctx = ssl.create_default_context()
+            raw = ctx.wrap_socket(raw, server_hostname=self.host.split(":")[0])
+        key = base64.b64encode(os.urandom(16)).decode()
+        req = (
+            f"GET {self.path} HTTP/1.1\r\n"
+            f"Host: {self.host}\r\n"
+            "Upgrade: websocket\r\n"
+            "Connection: Upgrade\r\n"
+            f"Sec-WebSocket-Key: {key}\r\n"
+            "Sec-WebSocket-Version: 13\r\n"
+        )
+        for k, v in self.extra_headers.items():
+            req += f"{k}: {v}\r\n"
+        req += "\r\n"
+        raw.sendall(req.encode())
+        raw.settimeout(self.timeout)
+        status, headers = self._read_http_response(raw)
+        if status != 101:
+            raw.close()
+            raise WsClosed(f"handshake rejected: HTTP {status}: {headers.get('x-error', headers)}")
+        expect = base64.b64encode(hashlib.sha1((key + _GUID).encode()).digest()).decode()
+        if headers.get("sec-websocket-accept") != expect:
+            raw.close()
+            raise WsClosed("bad Sec-WebSocket-Accept")
+        self.sock = raw
+
+    def _read_http_response(self, sock: socket.socket) -> tuple[int, dict]:
+        data = b""
+        while b"\r\n\r\n" not in data:
+            chunk = sock.recv(4096)
+            if not chunk:
+                raise WsClosed("connection closed during handshake")
+            data += chunk
+            if len(data) > 65536:
+                raise WsClosed("handshake response too large")
+        head, _, rest = data.partition(b"\r\n\r\n")
+        lines = head.decode("latin-1").split("\r\n")
+        status = int(lines[0].split(" ")[1]) if len(lines[0].split(" ")) > 1 else 0
+        headers = {}
+        for line in lines[1:]:
+            if ":" in line:
+                k, v = line.split(":", 1)
+                headers[k.strip().lower()] = v.strip()
+        # stash leftover bytes for frame reader
+        self._leftover = rest
+        return status, headers
+
+    # ---- frames ----------------------------------------------------------
+    @staticmethod
+    def _encode_frame(opcode: int, payload: bytes) -> bytes:
+        mask = os.urandom(4)
+        header = bytes([0x80 | opcode])
+        n = len(payload)
+        if n < 126:
+            header += bytes([0x80 | n])
+        elif n < 65536:
+            header += bytes([0x80 | 126]) + struct.pack(">H", n)
+        else:
+            header += bytes([0x80 | 127]) + struct.pack(">Q", n)
+        masked = bytes(b ^ mask[i % 4] for i, b in enumerate(payload))
+        return header + mask + masked
+
+    def _recv_exact(self, n: int) -> bytes:
+        assert self.sock is not None
+        buf = bytearray(self._leftover)
+        self._leftover = b""
+        while len(buf) < n:
+            try:
+                chunk = self.sock.recv(n - len(buf))
+            except socket.timeout as e:
+                raise WsIdleTimeout("read idle timeout") from e
+            except OSError as e:
+                raise WsClosed(f"socket error: {e}") from e
+            if not chunk:
+                raise WsClosed("connection closed")
+            buf.extend(chunk)
+        return bytes(buf)
+
+    def recv_frame(self) -> tuple[int, bytes]:
+        """Returns (opcode, payload). Auto-answers ping; raises WsClosed on close."""
+        if self.sock is None:
+            raise WsClosed("not connected")
+        b1, b2 = self._recv_exact(2)
+        opcode = b1 & 0x0F
+        masked = b2 & 0x80
+        n = b2 & 0x7F
+        if n == 126:
+            (n,) = struct.unpack(">H", self._recv_exact(2))
+        elif n == 127:
+            (n,) = struct.unpack(">Q", self._recv_exact(8))
+        mask = self._recv_exact(4) if masked else None
+        payload = self._recv_exact(n) if n else b""
+        if mask:
+            payload = bytes(b ^ mask[i % 4] for i, b in enumerate(payload))
+        if opcode == 0x9:  # ping -> pong
+            self._send_raw(0xA, payload)
+            return self.recv_frame()
+        if opcode == 0x8:
+            raise WsClosed(f"server closed: {payload[:120]!r}")
+        if opcode in (0x1, 0x2, 0x0):
+            return opcode, payload
+        return self.recv_frame()  # ignore unknown (e.g. pong)
+
+    def _send_raw(self, opcode: int, payload: bytes) -> None:
+        if self.sock is None:
+            raise WsClosed("not connected")
+        with self._send_lock:
+            self.sock.sendall(self._encode_frame(opcode, payload))
+
+    def send_text(self, text: str) -> None:
+        self._send_raw(0x1, text.encode())
+
+    def send_json(self, obj: dict) -> None:
+        self.send_text(json.dumps(obj, ensure_ascii=False))
+
+    def recv_json(self) -> dict:
+        while True:
+            _, payload = self.recv_frame()
+            return json.loads(payload.decode())
+
+    def close(self) -> None:
+        if self.sock is not None:
+            try:
+                self._send_raw(0x8, struct.pack(">H", 1000))
+            except OSError:
+                pass
+            try:
+                self.sock.close()
+            except OSError:
+                pass
+            self.sock = None

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.