clm-kernel 0.0.0__py3-none-any.whl

clm/layer1/operations/services.py

@@ -0,0 +1,529 @@
+"""
+Services Operations Module
+==========================
+
+Contains operations for managing long-running services (servers, daemons).
+Moved from builtins.py to separate concerns.
+"""
+
+from typing import Any
+
+from clm.cross_cutting.config.config_constants import (
+    DEFAULT_WS_HOST,
+    DEFAULT_WS_PORT,
+    ENV_WS_PORT,
+    ENV_WS_PORT_LEGACY,
+    SIGNALING_PORT_RELEASE_WAIT_SECS,
+)
+from clm.layer0.model.card import MCard
+
+NETWORK_DEFAULT_HOST = DEFAULT_WS_HOST
+PROCESS_TERMINATE_WAIT_SECONDS = SIGNALING_PORT_RELEASE_WAIT_SECS
+STATIC_SERVER_START_WAIT_SECONDS = 1.5
+WEBSOCKET_SERVER_START_WAIT_SECONDS = 3.0
+
+
+def op_static_server(impl: dict, target: MCard, ctx: dict) -> Any:
+    """
+    Execute static_server builtin - manages HTTP static file server.
+
+    Actions: deploy, status, stop
+    Config: root_dir, port, host
+    """
+    import os
+    import signal
+    import socket
+    import subprocess
+    import time
+
+    def _resolve_config_value(val: Any) -> Any:
+        """Resolve environment variables in config values like '${VAR}'."""
+        if isinstance(val, str) and val.startswith("${") and val.endswith("}"):
+            env_var = val[2:-1]
+            return os.getenv(env_var, val)
+        return val
+
+    # Valid config keys: port, host, root_dir
+    config = impl.get("config", {})
+    action = ctx.get("action") or config.get("action", "status")
+
+    # Default to HTTP_PORT from .env matching the project configuration
+    default_port = int(os.getenv("HTTP_PORT", 5320))
+    raw_port = ctx.get("port") or config.get("port", default_port)
+    port = int(_resolve_config_value(raw_port))
+
+    host = ctx.get("host") or config.get("host", NETWORK_DEFAULT_HOST)
+    root_dir = ctx.get("root_dir") or config.get("root_dir", ".")
+
+    # Resolve root_dir relative to project root
+    project_root = os.getcwd()
+    if not os.path.isabs(root_dir):
+        root_dir = os.path.normpath(os.path.join(project_root, root_dir))
+
+    pid_file = os.path.join(project_root, f".static_server_{port}.pid")
+
+    def is_port_in_use(p: int) -> bool:
+        # Use lsof to check if port is in use (handles both IPv4 and IPv6)
+        try:
+            result = subprocess.run(
+                ["lsof", "-ti", f":{p}"], capture_output=True, text=True
+            )
+            return result.returncode == 0 and result.stdout.strip() != ""
+        except (OSError, subprocess.SubprocessError):
+            # Fallback to socket check
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                return s.connect_ex(("localhost", p)) == 0
+
+    def get_pid_on_port(p: int):
+        try:
+            result = subprocess.run(
+                ["lsof", "-ti", f":{p}"], capture_output=True, text=True
+            )
+            if result.returncode == 0 and result.stdout.strip():
+                return int(result.stdout.strip().split("\n")[0])
+        except (OSError, subprocess.SubprocessError, ValueError):
+            pass
+        return None
+
+    if action == "deploy":
+        # Check if already running
+        if is_port_in_use(port):
+            pid = get_pid_on_port(port)
+            return {
+                "success": True,
+                "message": "Server already running",
+                "pid": pid,
+                "port": port,
+                "url": f"http://{host}:{port}",
+                "status": "already_running",
+            }
+
+        # Verify root_dir exists
+        if not os.path.isdir(root_dir):
+            return {"success": False, "error": f"Directory not found: {root_dir}"}
+
+        # Start Python HTTP server as background process
+        try:
+            process = subprocess.Popen(
+                [
+                    "python3",
+                    "-m",
+                    "http.server",
+                    str(port),
+                    "--bind",
+                    host,
+                    "--directory",
+                    root_dir,
+                ],
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                start_new_session=True,
+            )
+
+            # Save PID
+            with open(pid_file, "w") as f:
+                f.write(str(process.pid))
+
+            # Wait for server to start
+            time.sleep(STATIC_SERVER_START_WAIT_SECONDS)
+
+            if is_port_in_use(port):
+                return {
+                    "success": True,
+                    "message": "Server deployed successfully",
+                    "pid": process.pid,
+                    "port": port,
+                    "url": f"http://{host}:{port}",
+                    "root_dir": root_dir,
+                    "status": "running",
+                }
+            else:
+                return {"success": False, "error": "Server started but not responding"}
+
+        except (OSError, subprocess.SubprocessError, ValueError) as e:
+            return {"success": False, "error": f"Failed to start server: {e}"}
+
+    elif action == "status":
+        is_running = is_port_in_use(port)
+        pid = get_pid_on_port(port)
+
+        saved_pid = None
+        if os.path.isfile(pid_file):
+            try:
+                with open(pid_file) as f:
+                    saved_pid = int(f.read().strip())
+            except (OSError, ValueError):
+                pass
+
+        return {
+            "success": True,
+            "running": is_running,
+            "pid": pid,
+            "saved_pid": saved_pid,
+            "port": port,
+            "url": f"http://{host}:{port}" if is_running else None,
+            "status": "running" if is_running else "stopped",
+        }
+
+    elif action == "stop":
+        pid = get_pid_on_port(port)
+
+        if not pid:
+            if os.path.isfile(pid_file):
+                os.remove(pid_file)
+            return {
+                "success": True,
+                "message": "No server running on this port",
+                "port": port,
+                "status": "stopped",
+            }
+
+        try:
+            os.kill(pid, signal.SIGTERM)
+            time.sleep(PROCESS_TERMINATE_WAIT_SECONDS)
+
+            if is_port_in_use(port):
+                os.kill(pid, signal.SIGKILL)
+                time.sleep(PROCESS_TERMINATE_WAIT_SECONDS)
+
+            if os.path.isfile(pid_file):
+                os.remove(pid_file)
+
+            return {
+                "success": True,
+                "message": "Server stopped",
+                "pid": pid,
+                "port": port,
+                "status": "stopped",
+            }
+        except ProcessLookupError:
+            if os.path.isfile(pid_file):
+                os.remove(pid_file)
+            return {
+                "success": True,
+                "message": "Server was not running",
+                "port": port,
+                "status": "stopped",
+            }
+        except (OSError, subprocess.SubprocessError) as e:
+            return {"success": False, "error": f"Failed to stop server: {e}"}
+
+    else:
+        return {"success": False, "error": f"Unknown action: {action}"}
+
+
+def op_websocket_server(impl: dict, target: MCard, ctx: dict) -> Any:
+    """
+    Execute websocket_server builtin - manages a Python-based WebSocket server.
+
+    Actions: deploy, status, stop
+    Config: port, host
+
+    Uses Python's asyncio-based WebSocket server internally.
+    """
+    import os
+    import signal
+    import socket
+    import subprocess
+    import sys
+    import time
+
+    def _resolve_config_value(val: Any) -> Any:
+        """Resolve environment variables in config values like '${VAR}'."""
+        if isinstance(val, str) and val.startswith("${") and val.endswith("}"):
+            env_var = val[2:-1]
+            return os.getenv(env_var, val)
+        return val
+
+    # Valid config keys: port, host, root_dir
+    config = impl.get("config", {})
+    action = ctx.get("action") or config.get("action", "status")
+
+    # Default to the canonical shared websocket port, with legacy fallback.
+    default_port = int(
+        os.getenv(ENV_WS_PORT, os.getenv(ENV_WS_PORT_LEGACY, str(DEFAULT_WS_PORT)))
+    )
+    raw_port = ctx.get("port") or config.get("port", default_port)
+    port = int(_resolve_config_value(raw_port))
+
+    host = ctx.get("host") or config.get("host", NETWORK_DEFAULT_HOST)
+
+    project_root = os.getcwd()
+    pid_file = os.path.join(project_root, f".websocket_server_{port}.pid")
+
+    def is_port_in_use(p: int) -> bool:
+        # Use lsof to check if port is in use (handles both IPv4 and IPv6)
+        try:
+            result = subprocess.run(
+                ["lsof", "-ti", f":{p}"], capture_output=True, text=True
+            )
+            return result.returncode == 0 and result.stdout.strip() != ""
+        except (OSError, subprocess.SubprocessError):
+            # Fallback to socket check
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                return s.connect_ex(("localhost", p)) == 0
+
+    def get_pid_on_port(p: int):
+        try:
+            result = subprocess.run(
+                ["lsof", "-ti", f":{p}"], capture_output=True, text=True
+            )
+            if result.returncode == 0 and result.stdout.strip():
+                return int(result.stdout.strip().split("\n")[0])
+        except (OSError, subprocess.SubprocessError, ValueError):
+            pass
+        return None
+
+    if action == "deploy":
+        # Check if already running
+        if is_port_in_use(port):
+            pid = get_pid_on_port(port)
+            return {
+                "success": True,
+                "message": "WebSocket server already running",
+                "pid": pid,
+                "port": port,
+                "url": f"ws://{host}:{port}/",
+                "status": "already_running",
+            }
+
+        # Python WebSocket server script (inline)
+        ws_server_code = f'''
+import asyncio
+import json
+import signal
+import sys
+import time
+import yaml
+
+try:
+    import websockets
+except ImportError:
+    print("websockets module not found, using basic socket server")
+    sys.exit(1)
+
+# Import PTR components for CLM execution
+try:
+    from clm.layer0.loader import CLMChapterLoader
+except ImportError:
+    print("Warning: clm not available, CLM execution disabled")
+    CLMChapterLoader = None
+
+connected_clients = set()
+
+async def execute_clm(clm_yaml, input_data):
+    """Execute CLM code and return result"""
+    if not CLMChapterLoader:
+        return {{"error": "CLM execution not available - clm not installed"}}
+
+    import tempfile
+    import os
+
+    try:
+        start_time = time.time()
+
+        # Parse YAML to get metadata
+        clm_data = yaml.safe_load(clm_yaml)
+
+        # Write YAML to temporary file
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.yaml', delete=False) as f:
+            f.write(clm_yaml)
+            temp_path = f.name
+
+        try:
+            # Load chapter from YAML file
+            chapter = CLMChapterLoader.load_from_yaml(temp_path)
+
+            # Execute chapter's action directly with provided input
+            result, state, logs = chapter.action.execute(input_data, {{}})
+
+            execution_time = (time.time() - start_time) * 1000  # ms
+
+            return {{
+                "success": True,
+                "result": result,
+                "executionTime": execution_time,
+                "chapter": clm_data.get("chapter", {{}}).get("title", "Unknown"),
+                "concept": clm_data.get("clm", {{}}).get("abstract", {{}}).get("concept", "Unknown"),
+                "logs": logs
+            }}
+        finally:
+            # Clean up temp file
+            if os.path.exists(temp_path):
+                os.unlink(temp_path)
+
+    except (OSError, subprocess.SubprocessError, ValueError) as e:
+        return {{
+            "success": False,
+            "error": str(e),
+            "executionTime": 0
+        }}
+
+async def handler(websocket):
+    connected_clients.add(websocket)
+    try:
+        async for message in websocket:
+            try:
+                data = json.loads(message)
+                msg_type = data.get("type")
+                message_id = data.get("messageId")
+
+                if msg_type == "clm_execute":
+                    # Execute CLM
+                    clm_code = data.get("clm", "")
+                    input_data = data.get("input", {{}})
+
+                    result = await execute_clm(clm_code, input_data)
+
+                    # Send response with same messageId
+                    response = {{
+                        "messageId": message_id,
+                        **result
+                    }}
+                    await websocket.send(json.dumps(response))
+
+                elif msg_type == "ping":
+                    # Respond to ping
+                    await websocket.send(json.dumps({{
+                        "messageId": message_id,
+                        "type": "pong",
+                        "timestamp": data.get("timestamp")
+                    }}))
+                else:
+                    # Echo unknown messages
+                    response = json.dumps({{
+                        "messageId": message_id,
+                        "type": "echo",
+                        "original": message,
+                        "clients": len(connected_clients)
+                    }})
+                    await websocket.send(response)
+
+            except json.JSONDecodeError:
+                await websocket.send(json.dumps({{
+                    "error": "Invalid JSON"
+                }}))
+            except Exception as e:
+                await websocket.send(json.dumps({{
+                    "error": str(e)
+                }}))
+
+    except websockets.exceptions.ConnectionClosed:
+        pass
+    finally:
+        connected_clients.discard(websocket)
+
+async def main():
+    async with websockets.serve(handler, "{host}", {port}):
+        print("WebSocket CLM Execution Server running on ws://{host}:{port}/")
+        print("Ready to handle CLM execution requests")
+        await asyncio.Future()  # Run forever
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        pass
+'''
+
+        # Start Python WebSocket server as background process
+        try:
+            process = subprocess.Popen(
+                [sys.executable, "-c", ws_server_code],
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                start_new_session=True,
+            )
+
+            # Save PID
+            with open(pid_file, "w") as f:
+                f.write(str(process.pid))
+
+            # Wait for server to start
+            time.sleep(WEBSOCKET_SERVER_START_WAIT_SECONDS)
+
+            if is_port_in_use(port):
+                return {
+                    "success": True,
+                    "message": "WebSocket server deployed successfully",
+                    "pid": process.pid,
+                    "port": port,
+                    "url": f"ws://{host}:{port}/",
+                    "status": "running",
+                }
+            else:
+                return {
+                    "success": False,
+                    "error": "Server started but not responding. Ensure 'websockets' package is installed: pip install websockets",
+                }
+
+        except (OSError, subprocess.SubprocessError, ValueError) as e:
+            return {"success": False, "error": f"Failed to start server: {e}"}
+
+    elif action == "status":
+        is_running = is_port_in_use(port)
+        pid = get_pid_on_port(port)
+
+        saved_pid = None
+        if os.path.isfile(pid_file):
+            try:
+                with open(pid_file) as f:
+                    saved_pid = int(f.read().strip())
+            except (OSError, ValueError):
+                pass
+
+        return {
+            "success": True,
+            "running": is_running,
+            "pid": pid,
+            "saved_pid": saved_pid,
+            "port": port,
+            "url": f"ws://{host}:{port}/" if is_running else None,
+            "status": "running" if is_running else "stopped",
+        }
+
+    elif action == "stop":
+        pid = get_pid_on_port(port)
+
+        if not pid:
+            if os.path.isfile(pid_file):
+                os.remove(pid_file)
+            return {
+                "success": True,
+                "message": "No WebSocket server running on this port",
+                "port": port,
+                "status": "stopped",
+            }
+
+        try:
+            os.kill(pid, signal.SIGTERM)
+            time.sleep(PROCESS_TERMINATE_WAIT_SECONDS)
+
+            if is_port_in_use(port):
+                os.kill(pid, signal.SIGKILL)
+                time.sleep(PROCESS_TERMINATE_WAIT_SECONDS)
+
+            if os.path.isfile(pid_file):
+                os.remove(pid_file)
+
+            return {
+                "success": True,
+                "message": "WebSocket server stopped",
+                "pid": pid,
+                "port": port,
+                "status": "stopped",
+            }
+        except ProcessLookupError:
+            if os.path.isfile(pid_file):
+                os.remove(pid_file)
+            return {
+                "success": True,
+                "message": "WebSocket server was not running",
+                "port": port,
+                "status": "stopped",
+            }
+        except (OSError, subprocess.SubprocessError) as e:
+            return {"success": False, "error": f"Failed to stop server: {e}"}
+
+    else:
+        return {"success": False, "error": f"Unknown action: {action}"}

clm/layer1/operations/split.py

@@ -0,0 +1,117 @@
+"""Baldwin Split Operator (DEL-388-02).
+
+Decomposition Operator (÷): A -> A1 ⊗ A2.
+Decomposes a compound MCard/PCard manifest into orthogonal components or
+partitions input tokens across parallel branches, preserving triadic
+syntactic closure (abstract_spec, concrete_impl, balanced_exp).
+"""
+from __future__ import annotations
+
+import copy
+from typing import Any
+
+import yaml
+
+from clm.layer0.model.card import MCard
+
+
+def _parse_manifest(target: MCard | str | dict[str, Any]) -> dict[str, Any]:
+    """Extract dict manifest from target MCard or string."""
+    if isinstance(target, dict):
+        return copy.deepcopy(target)
+    if isinstance(target, MCard):
+        raw = target.get_content(as_text=True)
+    else:
+        raw = str(target)
+    try:
+        data = yaml.safe_load(raw)
+        if isinstance(data, dict):
+            return data
+    except Exception:
+        pass
+    return {
+        "abstract_spec": {"type": "raw_content", "payload": raw},
+        "concrete_impl": {"runtime": "python", "length": len(raw)},
+        "balanced_exp": {"invariants": ["noetherian_conservation"]},
+    }
+
+
+def ensure_triadic_closure(data: dict[str, Any], suffix: str = "") -> dict[str, Any]:
+    """Guarantee that data contains abstract_spec, concrete_impl, and balanced_exp."""
+    res = copy.deepcopy(data)
+    if "abstract_spec" not in res:
+        res["abstract_spec"] = res.get("abstract", {
+            "type": f"pcard/abstract_{suffix}" if suffix else "pcard/abstract",
+            "interface": "universal",
+        })
+    if "concrete_impl" not in res:
+        res["concrete_impl"] = res.get("concrete", {
+            "type": f"pcard/concrete_{suffix}" if suffix else "pcard/concrete",
+            "runtime": "python",
+        })
+    if "balanced_exp" not in res:
+        res["balanced_exp"] = res.get("balanced", {
+            "type": f"pcard/balanced_{suffix}" if suffix else "pcard/balanced",
+            "invariants": ["noetherian_conservation"],
+        })
+    return res
+
+
+def op_split(impl: dict[str, Any], target: MCard, ctx: dict[str, Any]) -> dict[str, Any]:
+    """Execute the Baldwin Split (÷) operation.
+
+    Args:
+        impl: Configuration dict for split (e.g. split_keys, branch_a_keys, branch_b_keys).
+        target: Target MCard to decompose.
+        ctx: Execution context.
+
+    Returns:
+        Dict containing decomposed branches, manifests, and closure proofs.
+    """
+    manifest = _parse_manifest(target)
+    split_keys = impl.get("split_keys", ctx.get("split_keys", []))
+    branch_a_keys = impl.get("branch_a_keys", ctx.get("branch_a_keys", []))
+    branch_b_keys = impl.get("branch_b_keys", ctx.get("branch_b_keys", []))
+
+    if branch_a_keys or branch_b_keys:
+        part_a = {k: manifest[k] for k in branch_a_keys if k in manifest}
+        part_b = {k: manifest[k] for k in branch_b_keys if k in manifest}
+    elif split_keys:
+        part_a = {k: manifest[k] for k in split_keys if k in manifest}
+        part_b = {k: v for k, v in manifest.items() if k not in split_keys}
+    else:
+        # Default orthogonal partition
+        keys = list(manifest.keys())
+        mid = max(1, len(keys) // 2)
+        part_a = {k: manifest[k] for k in keys[:mid]}
+        part_b = {k: manifest[k] for k in keys[mid:]}
+
+    manifest_a = ensure_triadic_closure(part_a, "branch_a")
+    manifest_b = ensure_triadic_closure(part_b, "branch_b")
+
+    yaml_a = yaml.dump(manifest_a, default_flow_style=False)
+    yaml_b = yaml.dump(manifest_b, default_flow_style=False)
+
+    mcard_a = MCard(yaml_a)
+    mcard_b = MCard(yaml_b)
+
+    return {
+        "success": True,
+        "operator": "split",
+        "syntactic_closure": True,
+        "branch_a": {
+            "manifest": manifest_a,
+            "hash": mcard_a.hash,
+            "content": yaml_a,
+        },
+        "branch_b": {
+            "manifest": manifest_b,
+            "hash": mcard_b.hash,
+            "content": yaml_b,
+        },
+        "mcard_a": mcard_a,
+        "mcard_b": mcard_b,
+    }
+
+
+__all__ = ["op_split", "ensure_triadic_closure"]