glink-engine 0.5.0__py3-none-any.whl

bus/agent_client.py

@@ -0,0 +1,166 @@
+# SPDX-License-Identifier: MIT
+"""
+agent_client — Glink shared Agent communication & workflow loading module
+
+Shared by: glink.py (one-shot) and glink-daemon.py (checkpoint-resume daemon).
+
+Exports:
+  - AGENT_PORTS:  Agent name → HTTP port mapping
+  - call_agent(): HTTP call to agent's /ask endpoint
+  - load_workflow(): Load YAML workflow from workflows/ or bus/projects/
+"""
+
+import json
+import os
+import re
+import sys
+import urllib.error
+import urllib.request
+import time
+
+# ── Agent port mapping (single source of truth) ────────────
+# One port can have multiple aliases
+AGENT_PORTS = {
+    "agent-1": 8420,
+    "agent-2": 8431,
+    "agent-3": 8432,
+    "agent-4": 8434,
+    "agent-5": 8435,
+    "agent-6": 8436,
+}
+
+# ── Project name sanitizer (prevents path traversal) ────
+_PROJECT_RE = re.compile(r"^[\w\-]+$")
+
+
+def _sanitize_project_name(name: str) -> str:
+    """Filter project name — only alphanumeric, underscore, hyphen allowed."""
+    safe = _PROJECT_RE.sub("", name)
+    if safe != name:
+        safe = re.sub(r"[^\w\-]", "", name)
+    return safe.strip().lower() or "unnamed"
+
+
+# ── HTTP call to agent ─────────────────────────────────────
+
+
+def call_agent(
+    agent: str,
+    task: str,
+    port: int | None = None,
+    timeout: int = 600,
+    parse_reply: bool = True,
+) -> dict:
+    """Call an agent's /ask endpoint via HTTP.
+
+    Args:
+        agent:        Agent name (e.g. "agent-1", "Forge")
+        task:         Task description for the agent
+        port:         Explicit port; falls back to AGENT_PORTS lookup
+        timeout:      Request timeout in seconds
+        parse_reply:  If True, try to parse JSON and extract 'reply' field.
+                      If False, return raw response text.
+
+    Returns:
+        {"status": "ok",     "output": "<reply or first 500 chars>"}
+        {"status": "failed", "error":  "<description>"}
+    """
+    p = port or AGENT_PORTS.get(agent, 8420)
+    url = f"http://127.0.0.1:{p}/ask"
+    payload = json.dumps({"message": task}).encode()
+    start = time.time()
+    try:
+        req = urllib.request.Request(
+            url,
+            data=payload,
+            headers={"Content-Type": "application/json"},
+            method="POST",
+        )
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            body = resp.read().decode()
+            dur = round(time.time() - start, 1)
+            if parse_reply:
+                try:
+                    data = json.loads(body)
+                    reply = data.get(
+                        "reply", data.get("response", data.get("output", body[:500]))
+                    )
+                    return {"status": "ok", "output": reply[:2000], "duration": dur}
+                except json.JSONDecodeError:
+                    return {"status": "ok", "output": body[:2000], "duration": dur}
+            return {"status": "ok", "output": body[:2000], "duration": dur}
+    except urllib.error.HTTPError as e:
+        dur = round(time.time() - start, 1)
+        return {
+            "status": "failed",
+            "error": f"HTTP {e.code}: {e.reason}",
+            "duration": dur,
+        }
+    except urllib.error.URLError:
+        dur = round(time.time() - start, 1)
+        return {
+            "status": "failed",
+            "error": f"Connection refused: {agent}(:{p})",
+            "duration": dur,
+        }
+    except Exception as e:
+        dur = round(time.time() - start, 1)
+        return {"status": "failed", "error": str(e), "duration": dur}
+
+
+# ── Workflow loading ───────────────────────────────────────
+
+
+def load_workflow(project_name: str, base_dir: str | None = None) -> dict:
+    """Load a workflow YAML. Searches workflows/ first, then bus/projects/.
+
+    Args:
+        project_name: Project name (sanitized by _sanitize_project_name)
+        base_dir:     Glink root directory; defaults to parent of this file
+
+    Returns:
+        Parsed workflow dict
+
+    Raises:
+        SystemExit(1): Workflow file not found
+    """
+    if base_dir is None:
+        base_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    safe_name = _sanitize_project_name(project_name)
+
+    # Search: workflows/<name>.yaml, workflows/<name>.yml, bus/projects/<name>.yaml
+    search_paths = []
+    base_wf = os.path.join(base_dir, "workflows")
+    for ext in (".yaml", ".yml"):
+        search_paths.append(os.path.join(base_wf, f"{safe_name}{ext}"))
+        search_paths.append(os.path.join(base_wf, f"{project_name}{ext}"))
+    bus_dir = os.path.join(base_dir, "bus", "projects")
+    search_paths.append(os.path.join(bus_dir, f"{safe_name}.yaml"))
+
+    for p in search_paths:
+        if os.path.exists(p):
+            try:
+                import yaml
+            except ImportError:
+                import subprocess
+
+                subprocess.check_call(
+                    [
+                        sys.executable,
+                        "-m",
+                        "pip",
+                        "install",
+                        "pyyaml",
+                        "-q",
+                        "--quiet",
+                        "--quiet",
+                    ],
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL,
+                )
+                import yaml  # noqa: F811
+            with open(p) as f:
+                return yaml.safe_load(f)
+
+    print(f"❌ Workflow not found: {safe_name}", file=sys.stderr)
+    sys.exit(1)

bus/main_bus.py

@@ -0,0 +1,178 @@
+# SPDX-License-Identifier: MIT
+"""
+Main Bus — Shared project timeline
+
+All agents read/write project-level shared memory through this module.
+
+Storage: JSONL (one event per line)
+Event types:
+  - task.created:    Task created
+  - task.assigned:   Task assigned to an agent
+  - task.started:    Task execution started
+  - task.completed:  Task completed
+  - task.failed:     Task failed
+  - task.log:        Execution log
+  - project.update:  Project status update
+"""
+
+import fcntl
+import json
+import os
+import sys
+
+BUS_ROOT = os.path.dirname(os.path.abspath(__file__))
+PROJECTS_DIR = os.path.join(BUS_ROOT, "projects")
+
+# Project name whitelist: only alphanumeric, underscore, hyphen (prevents path traversal)
+_PROJECT_RE = __import__("re").compile(r"^[\w\-]+$")
+
+
+def _sanitize(project_name: str) -> str:
+    """Filter project name, prevent path traversal (only [\\w\\-] allowed)."""
+    if not _PROJECT_RE.match(project_name):
+        import re as _re
+
+        return _re.sub(r"[^\w\-]", "", project_name).strip().lower() or "unnamed"
+    return project_name.strip().lower()
+
+
+def _bus_path(project_name: str) -> str:
+    """Get bus file path for project."""
+    safe = _sanitize(project_name)
+    os.makedirs(PROJECTS_DIR, exist_ok=True)
+    return os.path.join(PROJECTS_DIR, f"{safe}.jsonl")
+
+
+def write(
+    project_name: str, event_type: str, agent: str, data: dict, stage: str = ""
+) -> bool:
+    """Write an event to Main Bus (file-locked, concurrent-safe)."""
+    import time as _time
+
+    path = _bus_path(project_name)
+    ev = {
+        "type": event_type,
+        "agent": agent,
+        "data": data,
+        "stage": stage,
+        "ts": _time.time(),
+        "iso": __import__("datetime").datetime.now().isoformat(),
+    }
+    try:
+        with open(path, "a") as f:
+            fcntl.flock(f.fileno(), fcntl.LOCK_EX)
+            f.write(json.dumps(ev, ensure_ascii=False) + "\n")
+            f.flush()
+            os.fsync(f.fileno())
+        return True
+    except Exception:
+        # Write failure does not propagate — logged to stderr, won't crash the caller
+        import traceback
+
+        print(f"[MainBus] Write failed: {traceback.format_exc()}", file=sys.stderr)
+        return False
+
+
+def read(project_name: str, limit: int = 100) -> list[dict]:
+    """Read recent events from Main Bus."""
+    # BUG-02: Negative or zero n parameter validation (Forge 2026-05-25)
+    if limit <= 0:
+        return []
+    path = _bus_path(project_name)
+    if not os.path.exists(path):
+        return []
+    events = []
+    with open(path) as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                try:
+                    events.append(json.loads(line))
+                except json.JSONDecodeError:
+                    continue
+    return events[-limit:]
+
+
+def latest(project_name: str, event_type: str | None = None) -> dict | None:
+    """Get the latest event, optionally filtered by type."""
+    events = read(project_name)
+    if event_type:
+        for ev in reversed(events):
+            if ev["type"] == event_type:
+                return ev
+        return None
+    return events[-1] if events else None
+
+
+def status(project_name: str) -> dict:
+    """Get current project status summary."""
+    events = read(project_name, limit=500)
+    total = len(events)
+    stats = {"completed": 0, "failed": 0, "started": 0, "others": 0}
+    agents = set()
+    stages = set()
+    for ev in events:
+        et = ev.get("type", "")
+        if et == "task.completed":
+            stats["completed"] += 1
+        elif et == "task.failed":
+            stats["failed"] += 1
+        elif et == "task.started":
+            stats["started"] += 1
+        else:
+            stats["others"] += 1
+        agents.add(ev.get("agent", ""))
+        if ev.get("stage"):
+            stages.add(ev.get("stage", ""))
+    return {
+        "project": project_name,
+        "total_events": total,
+        "tasks_completed": stats["completed"],
+        "tasks_failed": stats["failed"],
+        "tasks_started": stats["started"],
+        "agents_involved": sorted(a for a in agents if a),
+        "stages": sorted(s for s in stages if s),
+    }
+
+
+if __name__ == "__main__":
+    # CLI entry
+    cmd = sys.argv[1] if len(sys.argv) > 1 else ""
+    if not cmd:
+        print(f"Usage: python3 {sys.argv[0]} <command> [args...]")
+        print("Commands: write, read, status, latest")
+        sys.exit(0)
+
+    proj = sys.argv[2] if len(sys.argv) > 2 else "hello-world"
+
+    if cmd == "write":
+        etype = sys.argv[3] if len(sys.argv) > 3 else "task.log"
+        agent = sys.argv[4] if len(sys.argv) > 4 else "cli"
+        data_str = sys.argv[5] if len(sys.argv) > 5 else '{"msg":"test"}'
+        try:
+            data = json.loads(data_str)
+        except json.JSONDecodeError:
+            data = {"msg": data_str}
+        write(proj, etype, agent, data)
+        print(f"Written: {etype}/{agent} to {proj}")
+
+    elif cmd == "read":
+        limit = int(sys.argv[3]) if len(sys.argv) > 3 else 20
+        evs = read(proj, limit)
+        for ev in evs:
+            print(json.dumps(ev, ensure_ascii=False)[:200])
+
+    elif cmd == "status":
+        s = status(proj)
+        print(f"Project: {s['project']}")
+        print(f"Total events: {s['total_events']}")
+        print("Tasks: created/started/completed/failed")
+        print(f"Agents: {', '.join(s['agents_involved'])}")
+        print(f"Stages: {', '.join(s['stages'])}")
+
+    elif cmd == "latest":
+        ev = latest(proj)
+        if ev:
+            print(json.dumps(ev, ensure_ascii=False)[:300])
+        else:
+            print("No events")

daemon/__init__.py

@@ -0,0 +1,15 @@
+# SPDX-License-Identifier: MIT
+# Glink Daemon package — entry aggregator module
+from .api import set_project, start_api_server  # noqa: F401
+from .checks import cleanup_pidfile, ensure_pid, self_restart  # noqa: F401
+from .core import load_workflow, run_workflow  # noqa: F401
+from .log import (  # noqa: F401
+    get_reporter,
+    log,
+    log_err,
+    log_ok,
+    log_retry,
+    log_step,
+    log_warn,
+    send_alert,
+)