monoco-toolkit 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

monoco/core/telemetry.py

@@ -1,7 +1,7 @@
 import os
 import uuid
 import json
-import httpx
+
 import time
 from pathlib import Path
 from typing import Optional, Dict, Any
@@ -73,7 +73,10 @@ class Telemetry:
 
         # Send asynchronously? For now, we'll do a simple non-blocking-ish call
         try:
+            import httpx
             httpx.post(f"{POSTHOG_HOST}/capture/", json=data, timeout=1.0)
+        except ImportError:
+            pass # Telemetry is optional
         except Exception:
             pass
 

monoco/features/issue/core.py

@@ -51,7 +51,11 @@ def parse_issue(file_path: Path) -> Optional[IssueMetadata]:
         data = yaml.safe_load(match.group(1))
         if not isinstance(data, dict):
              return None
-        return IssueMetadata(**data)
+        
+        # Inject path before validation to ensure it persists
+        data['path'] = str(file_path.absolute())
+        meta = IssueMetadata(**data)
+        return meta
     except Exception:
         return None
 
@@ -72,6 +76,8 @@ def parse_issue_detail(file_path: Path) -> Optional[IssueDetail]:
         data = yaml.safe_load(yaml_str)
         if not isinstance(data, dict):
              return None
+             
+        data['path'] = str(file_path.absolute())
         return IssueDetail(**data, body=body, raw_content=content)
     except Exception:
         return None
@@ -161,6 +167,9 @@ def create_issue_file(
     file_path = target_dir / filename
     file_path.write_text(file_content)
     
+    # Inject path into returned metadata
+    metadata.path = str(file_path.absolute())
+    
     return metadata, file_path
 def validate_transition(
     current_status: IssueStatus,

monoco/features/issue/models.py

@@ -105,7 +105,10 @@ class IssueMetadata(BaseModel):
     isolation: Optional[IssueIsolation] = None
     dependencies: List[str] = []
     related: List[str] = []
+    dependencies: List[str] = []
+    related: List[str] = []
     tags: List[str] = []
+    path: Optional[str] = None  # Absolute path to the issue file
 
 
     @model_validator(mode='before')

monoco/features/pty/core.py

@@ -0,0 +1,185 @@
+
+import asyncio
+import os
+import pty
+import select
+import signal
+import struct
+import fcntl
+import termios
+import logging
+from typing import Dict, Optional, Tuple, Any
+
+logger = logging.getLogger("monoco.pty")
+
+class PTYSession:
+    """
+    Manages a single PTY session connected to a subprocess (shell).
+    """
+    def __init__(self, session_id: str, cmd: list[str], env: Optional[Dict[str, str]] = None, cwd: Optional[str] = None):
+        self.session_id = session_id
+        self.cmd = cmd
+        self.env = env or os.environ.copy()
+        self.cwd = cwd or os.getcwd()
+        
+        self.fd: Optional[int] = None
+        self.pid: Optional[int] = None
+        self.proc = None # subprocess.Popen object
+        self.running = False
+        self.loop = asyncio.get_running_loop()
+
+    def start(self, cols: int = 80, rows: int = 24):
+        """
+        Spawn a subprocess connected to a new PTY using subprocess.Popen.
+        This provides better safety in threaded/asyncio environments than pty.fork().
+        """
+        import subprocess
+
+        # 1. Open PTY pair
+        master_fd, slave_fd = pty.openpty()
+        
+        # 2. Set initial size
+        self._set_winsize(master_fd, rows, cols)
+
+        try:
+            # 3. Spawn process
+            # start_new_session=True executes setsid()
+            self.proc = subprocess.Popen(
+                self.cmd,
+                stdin=slave_fd,
+                stdout=slave_fd,
+                stderr=slave_fd,
+                cwd=self.cwd,
+                env=self.env,
+                start_new_session=True,
+                close_fds=True # Important to close other FDs in child
+            )
+            
+            self.pid = self.proc.pid
+            self.fd = master_fd
+            self.running = True
+            
+            # 4. Close slave fd in parent (child has it open now)
+            os.close(slave_fd)
+            
+            logger.info(f"Started session {self.session_id} (PID: {self.pid})")
+            
+        except Exception as e:
+            logger.error(f"Failed to spawn process: {e}")
+            # Ensure we clean up fds if spawn fails
+            try:
+                os.close(master_fd)
+            except: pass
+            try:
+                os.close(slave_fd)
+            except: pass
+            raise e
+
+
+    def resize(self, cols: int, rows: int):
+        """
+        Resize the PTY.
+        """
+        if self.fd and self.running:
+            self._set_winsize(self.fd, rows, cols)
+
+    def write(self, data: bytes):
+        """
+        Write input data (from websocket) to the PTY master fd.
+        """
+        if self.fd and self.running:
+            os.write(self.fd, data)
+
+    async def read(self) -> bytes:
+        """
+        Read output data from PTY master fd (to forward to websocket).
+        """
+        if not self.fd or not self.running:
+            return b""
+            
+        try:
+            # Run in executor to avoid blocking the event loop
+            # pty read is blocking
+            return await self.loop.run_in_executor(None, self._read_blocking)
+        except OSError:
+            return b""
+
+    def _read_blocking(self) -> bytes:
+        try:
+            return os.read(self.fd, 1024)
+        except OSError:
+            return b""
+
+    def terminate(self):
+        """
+        Terminate the process and close the PTY.
+        """
+        self.running = False
+        
+        # Use Popen object if available
+        if self.proc:
+            try:
+                self.proc.terminate()
+                try:
+                    self.proc.wait(timeout=1.0)
+                except:
+                    # Force kill if not terminated
+                    self.proc.kill()
+                    self.proc.wait()
+            except Exception as e:
+                logger.error(f"Error terminating process: {e}")
+            self.proc = None
+            self.pid = None
+        elif self.pid:
+            # Fallback for legacy or if Popen obj lost
+            try:
+                os.kill(self.pid, signal.SIGTERM)
+                os.waitpid(self.pid, 0) # Reap zombie
+            except OSError:
+                pass
+            self.pid = None
+            
+        if self.fd:
+            try:
+                os.close(self.fd)
+            except OSError:
+                pass
+            self.fd = None
+        logger.info(f"Terminated session {self.session_id}")
+
+    def _set_winsize(self, fd: int, row: int, col: int, xpix: int = 0, ypix: int = 0):
+        winsize = struct.pack("HHHH", row, col, xpix, ypix)
+        fcntl.ioctl(fd, termios.TIOCSWINSZ, winsize)
+
+
+class PTYManager:
+    """
+    Singleton to manage multiple PTY sessions.
+    """
+    def __init__(self):
+        self.sessions: Dict[str, PTYSession] = {}
+
+    def create_session(self, session_id: str, cwd: str, cmd: list[str] = ["/bin/zsh"], env: Dict = None) -> PTYSession:
+        if session_id in self.sessions:
+            # In a real app, we might want to attach to existing?
+            # For now, kill and recreate (or error)
+            self.close_session(session_id)
+            
+        session = PTYSession(session_id, cmd, env, cwd)
+        self.sessions[session_id] = session
+        return session
+
+    def get_session(self, session_id: str) -> Optional[PTYSession]:
+        return self.sessions.get(session_id)
+
+    def close_session(self, session_id: str):
+        if session_id in self.sessions:
+            self.sessions[session_id].terminate()
+            del self.sessions[session_id]
+
+    def close_all_sessions(self):
+        """
+        Terminate all active PTY sessions.
+        """
+        for session_id in list(self.sessions.keys()):
+            self.close_session(session_id)

monoco/features/pty/router.py

@@ -0,0 +1,138 @@
+
+from fastapi import APIRouter, WebSocket, WebSocketDisconnect, Query
+from pydantic import BaseModel
+from typing import Optional, Dict
+import json
+import asyncio
+import logging
+import os
+from pathlib import Path
+from monoco.features.pty.core import PTYManager
+from monoco.core.config import get_config
+
+# We will use dependency injection or a global singleton for now
+# Ideally attached to app state
+pty_manager = PTYManager()
+
+router = APIRouter(prefix="/api/v1/pty", tags=["pty"])
+
+logger = logging.getLogger("monoco.pty")
+
+@router.websocket("/ws/{session_id}")
+async def websocket_pty_endpoint(
+    websocket: WebSocket, 
+    session_id: str,
+    cwd: Optional[str] = Query(None),
+    cols: int = Query(80), 
+    rows: int = Query(24),
+    env: Optional[str] = Query(None) # JSON-encoded env vars
+):
+    await websocket.accept()
+    
+    # Determine working directory
+    # 1. Provide explicit CWD in query
+    # 2. Or fallback to ProjectRoot from env (if integrated)
+    # 3. Or fallback to process CWD
+    
+    # Since monoco pty runs as a separate service, we expect CWD to be passed
+    # or we default to where monoco pty was started
+    working_dir = cwd if cwd else os.getcwd()
+    
+    # Prepare environment
+    env_vars = os.environ.copy()
+    env_vars["TERM"] = "xterm-256color"
+    env_vars["COLORTERM"] = "truecolor"
+    if "SHELL" not in env_vars:
+        env_vars["SHELL"] = "/bin/zsh"
+    if "HOME" not in env_vars:
+        import pathlib
+        env_vars["HOME"] = str(pathlib.Path.home())
+
+    # Filter out Trae/Gemini specific variables to avoid shell integration conflicts
+    # This prevents the shell from trying to write to IDE-specific logs which causes EPERM
+    keys_to_remove = [k for k in env_vars.keys() if k.startswith("TRAE_") or k.startswith("GEMINI_") or k == "AI_AGENT"]
+    for k in keys_to_remove:
+        del env_vars[k]
+
+    if env:
+        try:
+            custom_env = json.loads(env)
+            env_vars.update(custom_env)
+        except:
+            logger.warning("Failed to parse custom env vars")
+
+    # Start Session
+    try:
+        session = pty_manager.create_session(
+            session_id=session_id, 
+            cwd=working_dir,
+            cmd=["/bin/zsh", "-l"], # Use login shell to ensure full user environment
+            env=env_vars
+        )
+        session.start(cols, rows)
+    except Exception as e:
+        logger.error(f"Failed to start session: {e}")
+        await websocket.close(code=1011)
+        return
+
+    # Pipe Loop
+    reader_task = None
+    try:
+        # Task to read from PTY and send to WebSocket
+        async def pty_reader():
+            while session.running:
+                data = await session.read()
+                if not data:
+                    break
+                # xterm.js expects string or binary. We send string/bytes.
+                # Usually text is fine, but binary is safer for control codes.
+                await websocket.send_bytes(data)
+            
+            # If PTY exits, close WS
+            await websocket.close()
+
+        reader_task = asyncio.create_task(pty_reader())
+
+        # Main loop: Read from WebSocket and write to PTY
+        try:
+            while True:
+                # Receive message from Client (xterm.js)
+                # Message can be simple input string, or a JSON command (resize)
+                message = await websocket.receive()
+                
+                if message["type"] == "websocket.disconnect":
+                    raise WebSocketDisconnect(code=message.get("code", 1000))
+                
+                if "text" in message:
+                    payload = message["text"]
+                    
+                    # Check if it's a control message (Hack: usually client sends raw input)
+                    # We can enforce a protocol: binary for Input, text JSON for Control.
+                    try:
+                        # Try parsing as JSON control message
+                        cmd = json.loads(payload)
+                        if cmd.get("type") == "resize":
+                            session.resize(cmd["cols"], cmd["rows"])
+                            continue
+                    except:
+                        pass # Not JSON, treat as raw input
+                    
+                    session.write(payload.encode())
+                    
+                elif "bytes" in message:
+                    session.write(message["bytes"])
+        except RuntimeError:
+            # Handle "Cannot call 'receive' once a disconnect message has been received"
+            # This happens if Starlette/FastAPI already processed the disconnect internally
+            # but we called receive() again.
+            logger.info(f"Runtime disconnect for session {session_id}")
+
+    except WebSocketDisconnect:
+        logger.info(f"Client disconnected for session {session_id}")
+    except Exception as e:
+        logger.error(f"WebSocket error: {e}")
+    finally:
+        # Cleanup
+        pty_manager.close_session(session_id)
+        if reader_task and not reader_task.done():
+            reader_task.cancel()

monoco/features/pty/server.py

@@ -0,0 +1,56 @@
+import logging
+import signal
+import sys
+from typing import Optional
+from pathlib import Path
+from contextlib import asynccontextmanager
+import uvicorn
+from fastapi import FastAPI
+from monoco.features.pty.router import router as pty_router, pty_manager
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # Startup
+    yield
+    # Shutdown
+    logging.info("Shutting down PTY manager and cleaning up sessions...")
+    pty_manager.close_all_sessions()
+
+def run_pty_server(host: str = "127.0.0.1", port: int = 3124, cwd: Optional[Path] = None):
+    """
+    Entry point for the 'monoco pty' command.
+    """
+    # Configure Logging
+    logging.basicConfig(level=logging.INFO)
+    
+    # Register a manual signal handler to ensure we catch termination even if uvicorn misses it
+    # or if we are stuck before uvicorn starts.
+    def handle_signal(signum, frame):
+        logging.info(f"Received signal {signum}, initiating shutdown...")
+        # We rely on uvicorn to handle the actual exit loop for SIGINT/SIGTERM usually,
+        # but having this log confirms propagation.
+        # If uvicorn is running, it should catch this first. 
+        # If not, we exit manually.
+        sys.exit(0)
+
+    # Note: Uvicorn overwrites SIGINT/SIGTERM handlers by default. 
+    # relying on lifespan is the standard "Uvicorn way".
+    
+    app = FastAPI(title="Monoco PTY Service", lifespan=lifespan)
+    app.include_router(pty_router)
+    
+    # If cwd is provided, we might want to set it as current process CWD
+    # so that new sessions default to it.
+    if cwd and cwd.exists():
+        import os
+        os.chdir(cwd)
+        logging.info(f"PTY Service Root: {cwd}")
+
+    logging.info(f"Starting Monoco PTY Service on ws://{host}:{port}")
+    try:
+        uvicorn.run(app, host=host, port=port)
+    except KeyboardInterrupt:
+        pass
+    finally:
+        # Final safety net
+        pty_manager.close_all_sessions()

monoco/main.py

@@ -11,8 +11,24 @@ app = typer.Typer(
 )
 
 
+def version_callback(value: bool):
+    if value:
+        import importlib.metadata
+        try:
+            version = importlib.metadata.version("monoco-toolkit")
+        except importlib.metadata.PackageNotFoundError:
+            version = "unknown"
+        print(f"Monoco Toolkit v{version}")
+        raise typer.Exit()
+
+
 @app.callback()
-def main(ctx: typer.Context):
+def main(
+    ctx: typer.Context,
+    version: Optional[bool] = typer.Option(
+        None, "--version", "-v", help="Show version and exit", callback=version_callback, is_eager=True
+    ),
+):
     """
     Monoco Toolkit - The sensory and motor system for Monoco Agents.
     """
@@ -42,8 +58,14 @@ def info():
 
     mode = "Agent (JSON)" if os.getenv("AGENT_FLAG") == "true" else "Human (Rich)"
     
+    import importlib.metadata
+    try:
+        version = importlib.metadata.version("monoco-toolkit")
+    except importlib.metadata.PackageNotFoundError:
+        version = "unknown"
+
     status = Status(
-        version="0.1.0",
+        version=version,
         mode=mode,
         root=os.getcwd(),
         project=f"{settings.project.name} ({settings.project.key})"
@@ -69,5 +91,20 @@ app.add_typer(config_cmd.app, name="config", help="Manage configuration")
 from monoco.daemon.commands import serve
 app.command(name="serve")(serve)
 
+@app.command()
+def pty(
+    host: str = "127.0.0.1",
+    port: int = 3124,
+    cwd: Optional[str] = None
+):
+    """
+    Start the Monoco PTY Daemon (WebSocket).
+    """
+    from monoco.features.pty.server import run_pty_server
+    from pathlib import Path
+    
+    path = Path(cwd) if cwd else None
+    run_pty_server(host, port, path)
+
 if __name__ == "__main__":
     app()

{monoco_toolkit-0.1.1.dist-info → monoco_toolkit-0.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: monoco-toolkit
-Version: 0.1.1
+Version: 0.1.3
 Summary: Agent Native Toolkit for Monoco - Task Management & Kanban for AI Agents
 Project-URL: Homepage, https://monoco.io
 Project-URL: Repository, https://github.com/IndenScale/Monoco
@@ -83,7 +83,7 @@ monoco serve
 Then, launch the visual mission dashboard from anywhere:
 
 ```bash
-npx @monoco/kanban
+npx @monoco-io/kanban
 ```
 
 Visit `http://localhost:3123` (or the URL displayed in your terminal) to enter your cockpit.

{monoco_toolkit-0.1.1.dist-info → monoco_toolkit-0.1.3.dist-info}/RECORD

@@ -1,10 +1,10 @@
-monoco/main.py,sha256=XBYDD9kQt_a0wRIZ1vtOshRG8kUugach7CnHoAgS84I,2052
+monoco/main.py,sha256=_16blpwjqnSsmahwj9lJ6Cgm_6OVYw9BsdORepY3zX8,3058
 monoco/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 monoco/core/config.py,sha256=oiWB4bYkLGNhV9J3nGHdYjnVIux0gi8u9oYEpcvanpA,4768
 monoco/core/git.py,sha256=Qy5VjCKe0Y1y0rjqYULxT_viS7S4phTljf8hkd9DA8Q,6424
 monoco/core/output.py,sha256=CK8efvj0Q-pWrcJMdXwbuCyfsykWZ_pen9YWuDsivXQ,3192
 monoco/core/setup.py,sha256=qbMh6LV5wvXNYwquzxpmf3JZAoNDcwLClnNZ2QXPajs,8406
-monoco/core/telemetry.py,sha256=7sW468fTLFEfIGyTAsIagmJeQild07kIwM9M_KrPITM,2841
+monoco/core/telemetry.py,sha256=DZQGOhvpe0XL34RCDaTZEUhmkD4abBTZumZJQlALzpY,2923
 monoco/core/workspace.py,sha256=pFMC2culomxOF6Q1XqpEHCB8WjEEPBxKObUsOVpIG-E,1306
 monoco/daemon/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 monoco/daemon/app.py,sha256=RdNVjaB1JJUJ3_qCfKzBWyTRoNZV10KsBxoMHG--To8,12819
@@ -19,15 +19,18 @@ monoco/features/i18n/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hS
 monoco/features/i18n/commands.py,sha256=M_T8Ddw54p42wsZIowFjBq72mXKLsppzBRcHUByfhls,4816
 monoco/features/i18n/core.py,sha256=recjfNhJA2xdqFUMIivZ2omQZEzbgXJ1QvhjmvEDj24,5957
 monoco/features/issue/commands.py,sha256=w89KS19pJfMRzbIMIECQatalvPe4Q5rT8vSPfUnRQik,29448
-monoco/features/issue/core.py,sha256=FW3S-qdWw5XTze1X3fuNk8O6IbjJl2wRcrGXQYI02_Q,43483
+monoco/features/issue/core.py,sha256=iX-p7fTQUThKcAYOzlbBHldqG5naJV012cBvIxYIeFA,43778
 monoco/features/issue/linter.py,sha256=ZMNpp_0ehbzBMYROfPtCr4O4JL8mhdO9L0F3EAi96lE,7657
-monoco/features/issue/models.py,sha256=JCipMV2FMdyyvy-KIHtjOJHzcE2Cw_Hi-z1M3XfRQfI,4843
+monoco/features/issue/models.py,sha256=sepGxdgvRFRSc4tyvcUB9oXFBkDyS9_g0bGZEaE8Eq8,4970
+monoco/features/pty/core.py,sha256=eM1EvHQrgExSnatO15pyfhh1VZoz0BBTfNYdXqG8HZ8,5711
+monoco/features/pty/router.py,sha256=7h80EPpOuE7hX5ifkxkzffcLZGecd5X8OmNvOji5ToI,5078
+monoco/features/pty/server.py,sha256=kw2csMZ_R4_Xx6ta2dbznWtgNZLfrWOAkMp8NjlZYBc,1920
 monoco/features/skills/__init__.py,sha256=L8YNGPWyyFWq5WqNossfeB0AKHJF_omrn1VzJBrRFcM,23
 monoco/features/skills/core.py,sha256=mpd0Cq-k2MvHRTPq9saFvZgYXUBGJ9pnK5lUmzUfZbY,3418
 monoco/features/spike/commands.py,sha256=BpwYYIpihmezJACOxgQojsCM7RwXqL0_EB6wCl--Mm8,3947
 monoco/features/spike/core.py,sha256=FSlO3Lhz49_nyFp68TpxBdkFKksShz5S33Qxh74ZFpY,5150
-monoco_toolkit-0.1.1.dist-info/METADATA,sha256=Qc4fBORWFOoAGbGyTZAwmVWFsWJZg2f2tTNDiH_LKng,3740
-monoco_toolkit-0.1.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-monoco_toolkit-0.1.1.dist-info/entry_points.txt,sha256=iYj7FWYBdtClU15-Du1skqD0s6SFSIhJvxJ29VWp8ng,43
-monoco_toolkit-0.1.1.dist-info/licenses/LICENSE,sha256=ACAGGjV6aod4eIlVUTx1q9PZbnZGN5bBwkSs9RHj83s,1071
-monoco_toolkit-0.1.1.dist-info/RECORD,,
+monoco_toolkit-0.1.3.dist-info/METADATA,sha256=RGD_jbehEYX32G6R5sbGFPtuat0-TUFfYWOxlWLH_Ak,3743
+monoco_toolkit-0.1.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+monoco_toolkit-0.1.3.dist-info/entry_points.txt,sha256=iYj7FWYBdtClU15-Du1skqD0s6SFSIhJvxJ29VWp8ng,43
+monoco_toolkit-0.1.3.dist-info/licenses/LICENSE,sha256=ACAGGjV6aod4eIlVUTx1q9PZbnZGN5bBwkSs9RHj83s,1071
+monoco_toolkit-0.1.3.dist-info/RECORD,,