port42 0.1.0__tar.gz

port42-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,23 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+      - name: Install hatch
+        run: pip install hatch
+      - name: Build
+        run: hatch build
+      - name: Publish
+        uses: pypa/gh-action-pypi-publish@release/v1

port42-0.1.0/.gitignore

@@ -0,0 +1,10 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+.venv/
+venv/
+.port42/
+*.json
+!pyproject.toml

port42-0.1.0/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: port42
+Version: 0.1.0
+Summary: Python SDK for Port42 — connect external agents to your macOS companion
+Project-URL: Homepage, https://github.com/gordonmattey/port42-python
+License: MIT
+Requires-Python: >=3.10
+Requires-Dist: websockets>=12.0
+Provides-Extra: all
+Requires-Dist: click>=8.0; extra == 'all'
+Requires-Dist: langchain-core>=0.3; extra == 'all'
+Provides-Extra: cli
+Requires-Dist: click>=8.0; extra == 'cli'
+Provides-Extra: langchain
+Requires-Dist: langchain-core>=0.3; extra == 'langchain'
+Description-Content-Type: text/markdown
+
+# port42
+
+Python SDK for [Port42](https://github.com/gordonmattey/port42-native) — connect external agents to your macOS companion.
+
+## Install
+
+```bash
+pip install port42
+```
+
+## Quickstart
+
+```python
+from port42 import Agent
+
+agent = Agent("my-agent", channels=["#general"])
+
+@agent.on_mention
+def handle(msg):
+    return f"Hello {msg.sender}!"
+
+agent.run()
+```
+
+Port42 must be running. The agent connects via WebSocket and appears in your companion list.
+
+## With LangChain
+
+```bash
+pip install port42[langchain]
+```
+
+```python
+from port42 import Agent
+from port42.langchain import Port42CallbackHandler
+from langchain_anthropic import ChatAnthropic
+
+agent = Agent("assistant", channels=["#general"])
+handler = Port42CallbackHandler(agent)
+
+chain = ChatAnthropic(model="claude-sonnet-4-5")
+
+@agent.on_mention
+def handle(msg):
+    result = chain.invoke(msg.text, config={"callbacks": [handler]})
+    return result.content
+
+agent.run()
+```
+
+## Scaffold a project
+
+```bash
+pip install port42[cli]
+port42 init my-agent
+cd my-agent && python agent.py
+```
+
+Templates: `basic`, `langchain`, `pipeline`
+
+## Bridge APIs
+
+Once connected, your agent can call Port42 device APIs:
+
+```python
+agent.terminal_exec("ls ~/Desktop")
+agent.screen_capture(scale=0.5)
+agent.notify("Done", body="Pipeline complete")
+agent.port_push(port_id, {"key": "value"})
+agent.rest_call("https://api.example.com/data", secret="MY_API_KEY")
+```

port42-0.1.0/README.md

@@ -0,0 +1,71 @@
+# port42
+
+Python SDK for [Port42](https://github.com/gordonmattey/port42-native) — connect external agents to your macOS companion.
+
+## Install
+
+```bash
+pip install port42
+```
+
+## Quickstart
+
+```python
+from port42 import Agent
+
+agent = Agent("my-agent", channels=["#general"])
+
+@agent.on_mention
+def handle(msg):
+    return f"Hello {msg.sender}!"
+
+agent.run()
+```
+
+Port42 must be running. The agent connects via WebSocket and appears in your companion list.
+
+## With LangChain
+
+```bash
+pip install port42[langchain]
+```
+
+```python
+from port42 import Agent
+from port42.langchain import Port42CallbackHandler
+from langchain_anthropic import ChatAnthropic
+
+agent = Agent("assistant", channels=["#general"])
+handler = Port42CallbackHandler(agent)
+
+chain = ChatAnthropic(model="claude-sonnet-4-5")
+
+@agent.on_mention
+def handle(msg):
+    result = chain.invoke(msg.text, config={"callbacks": [handler]})
+    return result.content
+
+agent.run()
+```
+
+## Scaffold a project
+
+```bash
+pip install port42[cli]
+port42 init my-agent
+cd my-agent && python agent.py
+```
+
+Templates: `basic`, `langchain`, `pipeline`
+
+## Bridge APIs
+
+Once connected, your agent can call Port42 device APIs:
+
+```python
+agent.terminal_exec("ls ~/Desktop")
+agent.screen_capture(scale=0.5)
+agent.notify("Done", body="Pipeline complete")
+agent.port_push(port_id, {"key": "value"})
+agent.rest_call("https://api.example.com/data", secret="MY_API_KEY")
+```

port42-0.1.0/examples/basic/agent.py

@@ -0,0 +1,9 @@
+from port42 import Agent
+
+agent = Agent("echo", channels=["#general"])
+
+@agent.on_mention
+def handle(msg):
+    return f"Hello {msg.sender}! You said: {msg.text}"
+
+agent.run()

port42-0.1.0/examples/langchain/agent.py

@@ -0,0 +1,23 @@
+from port42 import Agent
+from port42.langchain import Port42CallbackHandler
+from langchain_anthropic import ChatAnthropic
+from langchain_core.prompts import ChatPromptTemplate
+
+agent = Agent("assistant", channels=["#general"])
+handler = Port42CallbackHandler(agent)
+
+prompt = ChatPromptTemplate.from_messages([
+    ("system", "You are a helpful assistant."),
+    ("human", "{input}"),
+])
+chain = prompt | ChatAnthropic(model="claude-sonnet-4-5")
+
+@agent.on_mention
+def handle(msg):
+    result = chain.invoke(
+        {"input": msg.text},
+        config={"callbacks": [handler]}
+    )
+    return result.content
+
+agent.run()

port42-0.1.0/examples/pipeline/agent.py

@@ -0,0 +1,25 @@
+from port42 import Agent
+
+agent = Agent("pipeline", channels=["#ops"])
+
+@agent.on_mention
+def handle(msg):
+    agent.typing()
+
+    # Run your pipeline
+    result = f"Processed: {msg.text}"
+
+    # Push a port with results
+    html = f"""<!DOCTYPE html>
+<html>
+<head><title>Pipeline Result</title><meta name="version" content="1"></head>
+<body style="padding:16px;font-family:monospace">
+  <p style="color:#00d4aa">Result</p>
+  <pre>{result}</pre>
+</body>
+</html>"""
+    agent.port_create(html=html, title="Pipeline Result")
+
+    return result
+
+agent.run()

port42-0.1.0/port42/__init__.py

@@ -0,0 +1,4 @@
+from .agent import Agent
+
+__all__ = ["Agent"]
+__version__ = "0.1.0"

port42-0.1.0/port42/agent.py

@@ -0,0 +1,304 @@
+import json
+import os
+import threading
+import time
+import uuid
+
+from .types import Message, Feedback
+
+
+class Agent:
+    def __init__(
+        self,
+        name: str,
+        channels: list[str] | None = None,
+        trigger: str = "mention",
+        gateway: str = "ws://127.0.0.1:4242",
+        tokens: list[str] | None = None,
+    ):
+        self.name = name
+        self.channels = channels or []
+        self.trigger = trigger
+        self.gateway_url = gateway.rstrip("/") + "/ws"
+        self.http_url = gateway.rstrip("/").replace("ws://", "http://").replace("wss://", "https://")
+        self._channel_tokens: dict[str, str] = dict(zip(channels or [], tokens or []))
+        self._channel_ids: list[str] = []
+        self._ws = None
+        self._handlers: dict[str, list] = {
+            "mention": [],
+            "message": [],
+            "feedback": [],
+        }
+        self._pending_calls: dict[str, threading.Event] = {}
+        self._call_results: dict[str, dict] = {}
+        self._recv_thread: threading.Thread | None = None
+        self._state_file = f".port42/{name}.json"
+        self.sender_id: str | None = None
+        self._load_state()
+        if not self.sender_id:
+            self.sender_id = f"agent-{name}-{uuid.uuid4().hex[:12]}"
+
+    # --- State persistence ---
+
+    def _load_state(self):
+        try:
+            with open(self._state_file) as f:
+                state = json.load(f)
+                self.sender_id = state.get("sender_id")
+        except FileNotFoundError:
+            pass
+
+    def _save_state(self):
+        os.makedirs(os.path.dirname(self._state_file), exist_ok=True)
+        with open(self._state_file, "w") as f:
+            json.dump({"sender_id": self.sender_id}, f)
+
+    # --- Decorators ---
+
+    def on_mention(self, fn):
+        self._handlers["mention"].append(fn)
+        return fn
+
+    def on_message(self, fn):
+        self._handlers["message"].append(fn)
+        return fn
+
+    def on_feedback(self, fn):
+        self._handlers["feedback"].append(fn)
+        return fn
+
+    # --- Run ---
+
+    def run(self):
+        """Block and listen for messages."""
+        self._connect()
+        self._recv_thread = threading.Thread(target=self._recv_loop, daemon=True)
+        self._recv_thread.start()
+        try:
+            self._recv_thread.join()
+        except KeyboardInterrupt:
+            self._disconnect()
+
+    # --- Connection ---
+
+    def _connect(self):
+        from websockets.sync.client import connect as ws_connect
+
+        print(f"[port42] connecting to {self.gateway_url} as {self.name} ({self.sender_id})")
+        self._ws = ws_connect(self.gateway_url)
+
+        # Auth handshake
+        auth_msg = json.loads(self._ws.recv())
+        if auth_msg["type"] == "challenge":
+            raise ConnectionError("Remote auth not yet supported — use a local gateway or provide a token")
+
+        # Identify
+        self._ws.send(json.dumps({
+            "type": "identify",
+            "sender_id": self.sender_id,
+            "sender_name": self.name,
+        }))
+        welcome = json.loads(self._ws.recv())
+        if welcome.get("type") != "welcome":
+            raise ConnectionError(f"Expected welcome, got: {welcome}")
+        self._save_state()
+        print(f"[port42] connected")
+
+        # Resolve channel names → IDs
+        if self.channels and not self._channel_ids:
+            self._channel_ids = self._resolve_channels(self.channels)
+
+        # Join channels
+        for ch_id in self._channel_ids:
+            join = {"type": "join", "channel_id": ch_id}
+            token = self._channel_tokens.get(ch_id)
+            if token:
+                join["token"] = token
+            self._ws.send(json.dumps(join))
+            # Drain until presence (joined) or error
+            for _ in range(10):
+                resp = json.loads(self._ws.recv())
+                if resp["type"] in ("presence", "error"):
+                    if resp["type"] == "error":
+                        print(f"[port42] failed to join {ch_id}: {resp.get('error')}")
+                    break
+
+    def _resolve_channels(self, names: list[str]) -> list[str]:
+        import urllib.request
+        url = self.http_url + "/call"
+        data = json.dumps({"method": "channel.list"}).encode()
+        req = urllib.request.Request(url, data=data, headers={"Content-Type": "application/json"})
+        with urllib.request.urlopen(req) as resp:
+            result = json.loads(resp.read())
+        # result is {"content": "[{...}]"} or direct list
+        content = result.get("content", result)
+        if isinstance(content, str):
+            channels = json.loads(content)
+        else:
+            channels = content
+        name_set = {n.lstrip("#").lower() for n in names}
+        ids = [ch["id"] for ch in channels if ch.get("name", "").lower() in name_set]
+        if not ids:
+            print(f"[port42] warning: no channels matched {names}")
+        return ids
+
+    def _disconnect(self):
+        if self._ws:
+            self._ws.close()
+
+    # --- Recv loop ---
+
+    def _recv_loop(self):
+        while True:
+            try:
+                raw = self._ws.recv()
+            except Exception as e:
+                print(f"[port42] disconnected: {e}")
+                break
+            env = json.loads(raw)
+            call_id = env.get("call_id")
+            if call_id and call_id in self._pending_calls:
+                self._call_results[call_id] = env
+                self._pending_calls[call_id].set()
+            else:
+                threading.Thread(target=self._dispatch, args=(env,), daemon=True).start()
+
+    def _dispatch(self, env: dict):
+        msg_type = env.get("type")
+
+        if msg_type == "message":
+            # Skip own messages
+            if env.get("sender_id") == self.sender_id:
+                return
+            msg = Message.from_envelope(env)
+            is_mention = f"@{self.name.lower()}" in (msg.text or "").lower()
+            if is_mention:
+                for handler in self._handlers["mention"]:
+                    try:
+                        result = handler(msg)
+                        if result is not None:
+                            self.send(str(result), channel_id=msg.channel_id)
+                    except Exception as e:
+                        print(f"[port42] handler error: {e}")
+            else:
+                for handler in self._handlers["message"]:
+                    try:
+                        result = handler(msg)
+                        if result is not None:
+                            self.send(str(result), channel_id=msg.channel_id)
+                    except Exception as e:
+                        print(f"[port42] handler error: {e}")
+
+        elif msg_type == "feedback":
+            fb = Feedback.from_envelope(env)
+            for handler in self._handlers["feedback"]:
+                try:
+                    handler(fb)
+                except Exception as e:
+                    print(f"[port42] feedback handler error: {e}")
+
+    # --- Send ---
+
+    def send(self, text: str, channel_id: str | None = None):
+        ch = channel_id or (self._channel_ids[0] if self._channel_ids else None)
+        if not ch:
+            raise RuntimeError("No channel to send to — specify channel_id or join a channel first")
+        env = {
+            "type": "message",
+            "channel_id": ch,
+            "sender_id": self.sender_id,
+            "sender_name": self.name,
+            "message_id": f"agent-{uuid.uuid4().hex[:16]}",
+            "payload": json.dumps({"text": text}),
+        }
+        self._ws.send(json.dumps(env))
+
+    def typing(self, channel_id: str | None = None):
+        ch = channel_id or (self._channel_ids[0] if self._channel_ids else None)
+        if not ch:
+            return
+        self._ws.send(json.dumps({
+            "type": "typing",
+            "channel_id": ch,
+            "sender_id": self.sender_id,
+        }))
+
+    # --- Bridge API ---
+
+    def _call(self, method: str, args: dict | None = None) -> dict:
+        call_id = f"sdk-{uuid.uuid4().hex[:12]}"
+        event = threading.Event()
+        self._pending_calls[call_id] = event
+        self._ws.send(json.dumps({
+            "type": "call",
+            "method": method,
+            "args": args or {},
+            "call_id": call_id,
+            "sender_id": self.sender_id,
+        }))
+        if not event.wait(timeout=30):
+            del self._pending_calls[call_id]
+            raise TimeoutError(f"{method} timed out")
+        result = self._call_results.pop(call_id)
+        del self._pending_calls[call_id]
+        if result.get("error"):
+            raise RuntimeError(result["error"])
+        payload = result.get("payload", "{}")
+        if isinstance(payload, (bytes, str)):
+            try:
+                return json.loads(payload)
+            except Exception:
+                return {"content": payload}
+        return payload or {}
+
+    def port_push(self, port_id: str, data: dict):
+        return self._call("port_push", {"id": port_id, "data": data})
+
+    def port_exec(self, port_id: str, js: str):
+        return self._call("port_exec", {"id": port_id, "js": js})
+
+    def port_patch(self, port_id: str, search: str, replace: str):
+        return self._call("port_patch", {"id": port_id, "search": search, "replace": replace})
+
+    def port_create(self, html: str, title: str | None = None):
+        return self._call("messages.send", {"text": f"```port\n{html}\n```"})
+
+    def ports_list(self):
+        return self._call("ports_list")
+
+    def rest_call(self, url: str, method: str = "GET", secret: str | None = None, **kwargs):
+        args: dict = {"url": url, "method": method}
+        if secret:
+            args["secret"] = secret
+        args.update(kwargs)
+        return self._call("rest.call", args)
+
+    def clipboard_read(self):
+        return self._call("clipboard.read")
+
+    def clipboard_write(self, data: str):
+        return self._call("clipboard.write", {"data": data})
+
+    def notify(self, title: str, body: str | None = None):
+        args: dict = {"title": title}
+        if body:
+            args["body"] = body
+        return self._call("notify.send", args)
+
+    def screen_capture(self, scale: float = 0.5):
+        return self._call("screen_capture", {"scale": scale})
+
+    def terminal_exec(self, command: str):
+        return self._call("terminal.exec", {"command": command})
+
+    def files_read(self, path: str):
+        return self._call("files.read", {"path": path})
+
+    def files_write(self, path: str, data: str):
+        return self._call("files.write", {"path": path, "data": data})
+
+    def storage_get(self, key: str, scope: str = "global"):
+        return self._call("storage.get", {"key": key, "scope": scope})
+
+    def storage_set(self, key: str, value, scope: str = "global"):
+        return self._call("storage.set", {"key": key, "value": value, "scope": scope})

port42-0.1.0/port42/cli.py

@@ -0,0 +1,90 @@
+try:
+    import click
+except ImportError:
+    raise ImportError("click is required: pip install port42[cli]")
+
+import os
+
+
+BASIC_TEMPLATE = '''from port42 import Agent
+
+agent = Agent("{name}", channels=["#general"])
+
+@agent.on_mention
+def handle(msg):
+    return f"Hello {{msg.sender}}! You said: {{msg.text}}"
+
+agent.run()
+'''
+
+LANGCHAIN_TEMPLATE = '''from port42 import Agent
+from port42.langchain import Port42CallbackHandler
+from langchain_anthropic import ChatAnthropic
+from langchain_core.prompts import ChatPromptTemplate
+
+agent = Agent("{name}", channels=["#general"])
+handler = Port42CallbackHandler(agent)
+
+prompt = ChatPromptTemplate.from_messages([
+    ("system", "You are a helpful assistant."),
+    ("human", "{{input}}"),
+])
+chain = prompt | ChatAnthropic(model="claude-sonnet-4-5")
+
+@agent.on_mention
+def handle(msg):
+    result = chain.invoke(
+        {{"input": msg.text}},
+        config={{"callbacks": [handler]}}
+    )
+    return result.content
+
+agent.run()
+'''
+
+PIPELINE_TEMPLATE = '''from port42 import Agent
+
+agent = Agent("{name}", channels=["#ops"])
+
+@agent.on_mention
+def handle(msg):
+    agent.typing()
+
+    # TODO: run your pipeline here
+    result = f"processed: {{msg.text}}"
+
+    # Optionally create a port to display results
+    # agent.port_create(html="<html>...</html>", title="Result")
+
+    return result
+
+agent.run()
+'''
+
+
+@click.group()
+def main():
+    pass
+
+
+@main.command()
+@click.argument("name")
+@click.option("--template", default="basic", help="Template: basic, langchain, pipeline")
+def init(name: str, template: str):
+    """Create a new Port42 agent project."""
+    os.makedirs(name, exist_ok=True)
+
+    templates = {
+        "basic": BASIC_TEMPLATE,
+        "langchain": LANGCHAIN_TEMPLATE,
+        "pipeline": PIPELINE_TEMPLATE,
+    }
+    if template not in templates:
+        raise click.BadParameter(f"Unknown template '{template}'. Choose: basic, langchain, pipeline")
+
+    agent_py = os.path.join(name, "agent.py")
+    with open(agent_py, "w") as f:
+        f.write(templates[template].format(name=name))
+
+    click.echo(f"Created {name}/agent.py")
+    click.echo(f"Run with: cd {name} && python agent.py")

port42-0.1.0/port42/langchain/__init__.py

@@ -0,0 +1,11 @@
+from .callback import Port42CallbackHandler
+from .tools import port42_tools, RestCallTool, ScreenCaptureTool, ClipboardTool, TerminalTool
+
+__all__ = [
+    "Port42CallbackHandler",
+    "port42_tools",
+    "RestCallTool",
+    "ScreenCaptureTool",
+    "ClipboardTool",
+    "TerminalTool",
+]

port42-0.1.0/port42/langchain/callback.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+try:
+    from langchain_core.callbacks import BaseCallbackHandler
+except ImportError:
+    raise ImportError("langchain-core is required: pip install port42[langchain]")
+
+
+class Port42CallbackHandler(BaseCallbackHandler):
+    """Streams LangChain execution progress into Port42 channels."""
+
+    def __init__(self, agent, channel_id: str | None = None):
+        self.agent = agent
+        self.channel_id = channel_id
+
+    def on_chain_start(self, serialized, inputs, **kwargs):
+        self.agent.typing(self.channel_id)
+
+    def on_chain_end(self, outputs, **kwargs):
+        if hasattr(outputs, "model_dump"):
+            # Pydantic model — render as port
+            self._render_as_port(outputs)
+        elif isinstance(outputs, str):
+            self.agent.send(outputs, channel_id=self.channel_id)
+
+    def on_chain_error(self, error, **kwargs):
+        self.agent.send(f"Chain error: {error}", channel_id=self.channel_id)
+
+    def on_tool_start(self, serialized, input_str, **kwargs):
+        self.agent.typing(self.channel_id)
+
+    def on_tool_end(self, output, **kwargs):
+        pass
+
+    def _render_as_port(self, model):
+        fields = model.model_dump()
+        rows = "".join(
+            f"<tr><td>{k}</td><td>{v}</td></tr>"
+            for k, v in fields.items()
+        )
+        html = f"""<!DOCTYPE html>
+<html>
+<head><title>{type(model).__name__}</title><meta name="version" content="1"></head>
+<body>
+<table style="width:100%;border-collapse:collapse;font-family:monospace;font-size:12px">
+{rows}
+</table>
+</body>
+</html>"""
+        self.agent.port_create(html=html, title=type(model).__name__)

port42-0.1.0/port42/langchain/tools.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+try:
+    from langchain_core.tools import BaseTool
+except ImportError:
+    raise ImportError("langchain-core is required: pip install port42[langchain]")
+
+from pydantic import Field
+
+
+class Port42Tool(BaseTool):
+    agent: object = Field(exclude=True)
+
+
+class RestCallTool(Port42Tool):
+    name: str = "rest_call"
+    description: str = "Make an HTTP request using Port42's secret store"
+
+    def _run(self, url: str, method: str = "GET", secret: str | None = None, **kwargs):
+        return self.agent.rest_call(url, method=method, secret=secret, **kwargs)
+
+
+class ScreenCaptureTool(Port42Tool):
+    name: str = "screen_capture"
+    description: str = "Take a screenshot of the user's screen"
+
+    def _run(self, scale: float = 0.5):
+        return self.agent.screen_capture(scale=scale)
+
+
+class ClipboardTool(Port42Tool):
+    name: str = "clipboard"
+    description: str = "Read or write the user's clipboard"
+
+    def _run(self, action: str = "read", data: str | None = None):
+        if action == "write" and data:
+            return self.agent.clipboard_write(data)
+        return self.agent.clipboard_read()
+
+
+class TerminalTool(Port42Tool):
+    name: str = "terminal_exec"
+    description: str = "Run a shell command on the user's machine"
+
+    def _run(self, command: str):
+        return self.agent.terminal_exec(command)
+
+
+def port42_tools(agent) -> list[BaseTool]:
+    return [
+        RestCallTool(agent=agent),
+        ScreenCaptureTool(agent=agent),
+        ClipboardTool(agent=agent),
+        TerminalTool(agent=agent),
+    ]

port42-0.1.0/port42/types.py

@@ -0,0 +1,50 @@
+from dataclasses import dataclass, field
+import json
+
+
+@dataclass
+class Message:
+    text: str
+    sender: str
+    sender_id: str
+    channel_id: str
+    message_id: str
+    timestamp: int
+    history: list = field(default_factory=list)
+
+    @classmethod
+    def from_envelope(cls, env: dict) -> "Message":
+        payload = json.loads(env.get("payload", "{}") or "{}")
+        if isinstance(payload, bytes):
+            payload = json.loads(payload)
+        return cls(
+            text=payload.get("text", ""),
+            sender=env.get("sender_name", ""),
+            sender_id=env.get("sender_id", ""),
+            channel_id=env.get("channel_id", ""),
+            message_id=env.get("message_id", ""),
+            timestamp=env.get("timestamp", 0),
+            history=payload.get("history", []),
+        )
+
+
+@dataclass
+class Feedback:
+    message_id: str
+    type: str
+    content: str
+    sender: str
+    sender_id: str
+
+    @classmethod
+    def from_envelope(cls, env: dict) -> "Feedback":
+        payload = json.loads(env.get("payload", "{}") or "{}")
+        if isinstance(payload, bytes):
+            payload = json.loads(payload)
+        return cls(
+            message_id=env.get("message_id", ""),
+            type=payload.get("feedback_type", ""),
+            content=payload.get("content", ""),
+            sender=env.get("sender_name", ""),
+            sender_id=env.get("sender_id", ""),
+        )

port42-0.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "port42"
+version = "0.1.0"
+description = "Python SDK for Port42 — connect external agents to your macOS companion"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+dependencies = [
+    "websockets>=12.0",
+]
+
+[project.optional-dependencies]
+langchain = [
+    "langchain-core>=0.3",
+]
+cli = [
+    "click>=8.0",
+]
+all = [
+    "port42[langchain,cli]",
+]
+
+[project.scripts]
+port42 = "port42.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/gordonmattey/port42-python"