cooloo 0.1.0__py3-none-win_amd64.whl

cooloo-0.1.0.data/purelib/cooloo/__init__.py

@@ -0,0 +1,5 @@
+"""cooloo: Python API and launcher for the bundled GUI+CLI client."""
+from .client import Client, CoolooError, Message, MessageStream, SendOutcomeUnknown, SentResult
+
+__version__ = "0.1.0"
+__all__ = ["Client", "CoolooError", "Message", "MessageStream", "SendOutcomeUnknown", "SentResult"]

cooloo-0.1.0.data/purelib/cooloo/_bin/manifest.json

@@ -0,0 +1,7 @@
+{
+  "filename": "cooloo.exe",
+  "version": "0.2.3",
+  "source_commit": "2ac3f027aca3b5f6a746e490bf5dd3384fc0b746",
+  "sha256": "19079ec6c559eb58c5ddac6807669ba51b34fa830103246cdae003b7613fc28a",
+  "platform_tag": "win_amd64"
+}

cooloo-0.1.0.data/purelib/cooloo/_licenses/JetBrainsMono.txt

@@ -0,0 +1,93 @@
+Copyright 2020 The JetBrains Mono Project Authors (https://github.com/JetBrains/JetBrainsMono)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+https://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

cooloo-0.1.0.data/purelib/cooloo/_licenses/Lua.txt

@@ -0,0 +1,25 @@
+/******************************************************************************
+* Copyright (C) 1994-2026 Lua.org, PUC-Rio.
+*
+* Permission is hereby granted, free of charge, to any person obtaining
+* a copy of this software and associated documentation files (the
+* "Software"), to deal in the Software without restriction, including
+* without limitation the rights to use, copy, modify, merge, publish,
+* distribute, sublicense, and/or sell copies of the Software, and to
+* permit persons to whom the Software is furnished to do so, subject to
+* the following conditions:
+*
+* The above copyright notice and this permission notice shall be
+* included in all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+******************************************************************************/
+
+
+#endif

cooloo-0.1.0.data/purelib/cooloo/_licenses/Monocypher.txt

@@ -0,0 +1,53 @@
+// Monocypher version 4.0.2
+//
+// This file is dual-licensed.  Choose whichever licence you want from
+// the two licences listed below.
+//
+// The first licence is a regular 2-clause BSD licence.  The second licence
+// is the CC-0 from Creative Commons. It is intended to release Monocypher
+// to the public domain.  The BSD licence serves as a fallback option.
+//
+// SPDX-License-Identifier: BSD-2-Clause OR CC0-1.0
+//
+// ------------------------------------------------------------------------
+//
+// Copyright (c) 2017-2020, Loup Vaillant
+// All rights reserved.
+//
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+//    notice, this list of conditions and the following disclaimer in the
+//    documentation and/or other materials provided with the
+//    distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ------------------------------------------------------------------------
+//
+// Written in 2017-2020 by Loup Vaillant
+//
+// To the extent possible under law, the author(s) have dedicated all copyright
+// and related neighboring rights to this software to the public domain
+// worldwide.  This software is distributed without any warranty.
+//
+// You should have received a copy of the CC0 Public Domain Dedication along
+// with this software.  If not, see
+// <https://creativecommons.org/publicdomain/zero/1.0/>
+

cooloo-0.1.0.data/purelib/cooloo/_licenses/SDL.txt

@@ -0,0 +1,18 @@
+Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+  
+This software is provided 'as-is', without any express or implied
+warranty.  In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+  
+1. The origin of this software must not be misrepresented; you must not
+   claim that you wrote the original software. If you use this software
+   in a product, an acknowledgment in the product documentation would be
+   appreciated but is not required. 
+2. Altered source versions must be plainly marked as such, and must not be
+   misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+

cooloo-0.1.0.data/purelib/cooloo/_licenses/cooloo-client-MIT.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 cooloo contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cooloo-0.1.0.data/purelib/cooloo/_licenses/stb_truetype.txt

@@ -0,0 +1,37 @@
+ALTERNATIVE A - MIT License
+Copyright (c) 2017 Sean Barrett
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+------------------------------------------------------------------------------
+ALTERNATIVE B - Public Domain (www.unlicense.org)
+This is free and unencumbered software released into the public domain.
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
+software, either in source code form or as a compiled binary, for any purpose,
+commercial or non-commercial, and by any means.
+In jurisdictions that recognize copyright laws, the author or authors of this
+software dedicate any and all copyright interest in the software to the public
+domain. We make this dedication for the benefit of the public at large and to
+the detriment of our heirs and successors. We intend this dedication to be an
+overt act of relinquishment in perpetuity of all present and future rights to
+this software under copyright law.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+------------------------------------------------------------------------------
+*/

cooloo-0.1.0.data/purelib/cooloo/client.py

@@ -0,0 +1,340 @@
+"""Thin subprocess adapter for cooloo's JSONL CLI schema 1. No wire protocol."""
+from __future__ import annotations
+
+from collections import deque
+from dataclasses import dataclass
+import json
+import os
+from pathlib import Path
+import queue
+import subprocess
+import threading
+import time
+from typing import Iterator
+
+
+class CoolooError(RuntimeError):
+    def __init__(self, code: str, message: str):
+        super().__init__(f"{code}: {message}")
+        self.code = code
+        self.message = message
+
+
+class SendOutcomeUnknown(CoolooError):
+    pass
+
+
+def _error(code: str, message: str) -> CoolooError:
+    return (SendOutcomeUnknown if code == "send-outcome-unknown" else CoolooError)(code, message)
+
+
+def binary_path(explicit: str | Path | None = None) -> Path:
+    path = Path(explicit).expanduser().resolve() if explicit else Path(__file__).parent / "_bin" / ("cooloo.exe" if os.name == "nt" else "cooloo")
+    if not path.is_file():
+        raise CoolooError("binary-missing", "install the matching platform wheel or specify binary= explicitly")
+    return path
+
+
+@dataclass(frozen=True)
+class Message:
+    ts: int
+    sender: str
+    destination: str
+    content: str
+    end_offset: int
+
+    @classmethod
+    def from_event(cls, event: dict) -> Message:
+        try:
+            m = event["message"]
+            if not isinstance(m["ts"], int) or not all(isinstance(m[k], str) for k in ("from", "to", "content")):
+                raise ValueError()
+            offset = event["end_offset"]
+            if type(offset) is not int or offset < 0:
+                raise ValueError()
+            return cls(m["ts"], m["from"], m["to"], m["content"], offset)
+        except (KeyError, TypeError, ValueError) as exc:
+            raise CoolooError("protocol-error", "invalid message event") from exc
+
+
+@dataclass(frozen=True)
+class SentResult:
+    messages: list[Message]
+    scan_offset: int
+
+
+def _stop(proc: subprocess.Popen) -> None:
+    if proc.poll() is None:
+        proc.terminate()
+        try:
+            proc.wait(timeout=2)
+        except subprocess.TimeoutExpired:
+            proc.kill()
+    proc.wait()
+
+
+class EventStream:
+    """Context-managed stream. Always close early-abandoned streams."""
+    def __init__(self, args: list[str], env: dict, payload: bytes | None, timeout: float | None, idle_timeout: float | None, sending: bool):
+        self._deadline = None if timeout is None else time.monotonic() + timeout
+        self._idle_timeout = idle_timeout
+        self._sending = sending
+        self._closed = False
+        self._terminal = False
+        self._events: queue.Queue = queue.Queue(maxsize=64)
+        self._stop_event = threading.Event()
+        self._diagnostics: deque[bytes] = deque(maxlen=16)
+        try:
+            self._proc = subprocess.Popen(args, stdin=subprocess.PIPE if payload is not None else subprocess.DEVNULL,
+                                          stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env,
+                                          creationflags=subprocess.CREATE_NO_WINDOW if os.name == "nt" else 0)
+        except OSError as exc:
+            raise CoolooError("process-start-failed", str(exc)) from exc
+        self._threads = [threading.Thread(target=self._read_stdout, daemon=True), threading.Thread(target=self._read_stderr, daemon=True)]
+        for thread in self._threads:
+            thread.start()
+        if payload is not None:
+            try:
+                self._proc.stdin.write(payload)  # bounded by SEND's 4096-byte limit
+                self._proc.stdin.close()
+            except (BrokenPipeError, OSError):
+                pass  # consume the structured error or process status
+
+    def _put(self, event) -> None:
+        while not self._stop_event.is_set():
+            try:
+                self._events.put(event, timeout=.1)
+                return
+            except queue.Full:
+                pass
+
+    def _read_stdout(self) -> None:
+        try:
+            while True:
+                line = self._proc.stdout.readline(131073)
+                if not line:
+                    break
+                if len(line) > 131072 or not line.endswith(b"\n"):
+                    raise CoolooError("protocol-error", "oversized or incomplete JSONL event")
+                try:
+                    event = json.loads(line.decode("utf-8"))
+                except (UnicodeError, ValueError) as exc:
+                    raise CoolooError("protocol-error", "invalid JSONL") from exc
+                if not isinstance(event, dict) or event.get("schema") != 1 or event.get("type") not in {"message", "room", "result", "end", "error"}:
+                    raise CoolooError("protocol-error", "unsupported event schema/type")
+                self._put(event)
+        except Exception as exc:
+            self._put(exc)
+        finally:
+            self._put(None)
+
+    def _read_stderr(self) -> None:
+        while True:
+            data = self._proc.stderr.read(4096)
+            if not data:
+                return
+            self._diagnostics.append(data)
+
+    def __iter__(self):
+        return self
+
+    def __next__(self) -> dict:
+        if self._closed:
+            raise StopIteration
+        wait = self._idle_timeout
+        if self._deadline is not None:
+            remaining = max(0, self._deadline - time.monotonic())
+            wait = remaining if wait is None else min(wait, remaining)
+        try:
+            event = self._events.get(timeout=wait)
+            if isinstance(event, Exception):
+                raise event
+            if event is None:
+                self._proc.wait(timeout=max(.001, self._deadline-time.monotonic()) if self._deadline else 2)
+                if self._proc.returncode != 0 or not self._terminal:
+                    raise _error("send-outcome-unknown" if self._sending and not self._terminal else "process-failed", "CLI exited without successful completion")
+                self.close()
+                raise StopIteration
+            if self._terminal:
+                raise CoolooError("protocol-error", "event after terminal result")
+            if event["type"] == "error":
+                raise _error(event.get("code", "protocol-error"), event.get("message", "CLI failed"))
+            if event["type"] in {"result", "end"}:
+                self._terminal = True
+            return event
+        except (queue.Empty, subprocess.TimeoutExpired) as exc:
+            self.close()
+            raise _error("send-outcome-unknown" if self._sending and not self._terminal else "timeout", "CLI deadline exceeded") from exc
+        except Exception:
+            self.close()
+            raise
+
+    def close(self) -> None:
+        if self._closed:
+            return
+        self._closed = True
+        self._stop_event.set()
+        _stop(self._proc)
+        for thread in self._threads:
+            thread.join(timeout=3)
+        for pipe in (self._proc.stdin, self._proc.stdout, self._proc.stderr):
+            if pipe is not None:
+                pipe.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *_):
+        self.close()
+
+
+class MessageStream:
+    def __init__(self, events: EventStream, offset: int, follow: bool):
+        self._events = events
+        self._offset = offset
+        self._follow = follow
+        self.next_offset: int | None = None
+
+    def __iter__(self) -> Iterator[Message]:
+        return self
+
+    def __next__(self) -> Message:
+        try:
+            event = next(self._events)
+            if event["type"] == "end" and not self._follow:
+                cursor = event.get("next_offset")
+                if type(cursor) is not int or cursor != self._offset:
+                    raise CoolooError("protocol-error", "invalid read cursor")
+                self.next_offset = cursor
+                try:
+                    next(self._events)
+                except StopIteration:
+                    raise
+                raise CoolooError("protocol-error", "event after end")
+            if event["type"] != "message":
+                raise CoolooError("protocol-error", "expected message")
+            message = Message.from_event(event)
+            if message.end_offset <= self._offset:
+                raise CoolooError("protocol-error", "non-increasing cursor")
+            self._offset = message.end_offset
+            return message
+        except Exception:
+            self.close()
+            raise
+
+    def close(self):
+        self._events.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *_):
+        self.close()
+
+
+class Client:
+    """One CLI process per call. No retries, implicit registration or shared cache."""
+    def __init__(self, *, binary: str | Path | None = None, host: str | None = None,
+                 config_dir: str | Path | None = None, tofu: bool = False,
+                 effective_identity: str | None = None, timeout: float = 30):
+        self.binary = binary_path(binary)
+        self._env = dict(os.environ)
+        if host is not None:
+            self._env["COOLOO_HOST"] = host
+        if config_dir is not None:
+            self._env["COOLOO_CONFIG"] = str(Path(config_dir).expanduser().resolve())
+        self._prefix = [str(self.binary), "--json"]
+        if tofu:
+            self._prefix.append("--tofu")
+        if effective_identity:
+            self._prefix += ["--as", effective_identity]
+        if timeout <= 0:
+            raise ValueError("timeout must be positive")
+        self.timeout = timeout
+        with EventStream([str(self.binary), "--json", "version"], self._env, None, timeout, None, False) as stream:
+            events = list(stream)
+        if len(events) != 1 or events[0].get("type") != "result" or 1 not in events[0].get("schema_versions", []) or not {"json-output", "follow-offset", "no-cache"} <= set(events[0].get("capabilities", [])):
+            raise CoolooError("incompatible-binary", "CLI schema 1 with explicit offsets is required")
+        self.binary_version = events[0]["binary_version"]
+
+    @staticmethod
+    def _offset(offset: int) -> str:
+        if type(offset) is not int or not 0 <= offset <= 2**63-1:
+            raise ValueError("offset must be a nonnegative signed 64-bit integer")
+        return str(offset)
+
+    def _stream(self, *args: str, payload: bytes | None = None, follow: bool = False, idle_timeout: float | None = None):
+        return EventStream(self._prefix + list(args), self._env, payload,
+                           None if follow else self.timeout, idle_timeout, args[0] in {"send", "join"})
+
+    def _result(self, *args: str, payload: bytes | None = None) -> dict:
+        with self._stream(*args, payload=payload) as stream:
+            events = list(stream)
+        if len(events) != 1 or events[0]["type"] != "result":
+            raise CoolooError("protocol-error", "expected one result")
+        return {k: v for k, v in events[0].items() if k not in {"schema", "type"}}
+
+    def keygen(self) -> str:
+        return self._result("keygen")["id"]
+
+    def register(self, nickname: str) -> dict:
+        return self._result("whoami", "--register", nickname)
+
+    def whoami(self) -> dict:
+        return self._result("whoami")
+
+    def send(self, destination: str, content: str) -> int:
+        payload = content.encode("utf-8")
+        if not 1 <= len(payload) <= 4096 or b"\0" in payload:
+            raise ValueError("content must be 1–4096 UTF-8 bytes without NUL")
+        return self._result("send", destination, payload=payload)["end_offset"]
+
+    def read(self, destination: str, *, offset: int) -> MessageStream:
+        return MessageStream(self._stream("read", destination, self._offset(offset)), offset, False)
+
+    def follow(self, destination: str, *, offset: int, idle_timeout: float | None = None) -> MessageStream:
+        if idle_timeout is not None and idle_timeout <= 0:
+            raise ValueError("idle_timeout must be positive")
+        return MessageStream(self._stream("follow", destination, self._offset(offset), follow=True, idle_timeout=idle_timeout), offset, True)
+
+    def sent(self, peer: str, *, offset: int) -> SentResult:
+        with self._stream("sent", peer, self._offset(offset)) as stream:
+            events = list(stream)
+        if not events or events[-1]["type"] != "end" or any(e["type"] != "message" for e in events[:-1]):
+            raise CoolooError("protocol-error", "invalid sent result")
+        messages = [Message.from_event(e) for e in events[:-1]]
+        cursor = events[-1].get("scan_offset")
+        if type(cursor) is not int or cursor < offset or (messages and cursor < messages[-1].end_offset):
+            raise CoolooError("protocol-error", "invalid scan cursor")
+        return SentResult(messages, cursor)
+
+    def rooms(self) -> list[dict]:
+        with self._stream("rooms") as stream:
+            events = list(stream)
+        if not events or events[-1]["type"] != "end" or any(e["type"] != "room" for e in events[:-1]):
+            raise CoolooError("protocol-error", "invalid rooms result")
+        return [{"id": e["id"], "nickname": e["nickname"]} for e in events[:-1]]
+
+    def create_room(self, nickname: str) -> dict:
+        return self._result("create", nickname)
+
+    def meta(self, identity: str) -> dict:
+        return self._result("meta", identity)
+
+    def rename(self, identity: str, nickname: str) -> None:
+        self._result("rename", identity, nickname)
+
+    def avatar(self, slot: int, child_id: str, nickname: str) -> dict:
+        return self._result("avatar", f"{slot:03d}", child_id, nickname)
+
+    def join(self, room: str) -> int:
+        return self._result("join", room)["end_offset"]
+
+    def approve_join(self, room: str, applicant: str) -> int:
+        return self.send(room, f"@{room} join-approve {applicant}")
+
+    def set_room_mode(self, room: str, mode: str) -> None:
+        self._result("room-mode", room, mode)
+
+    def delegate(self, child_id: str, permissions: str) -> None:
+        self._result("delegate", child_id, permissions)

cooloo-0.1.0.data/purelib/cooloo/launcher.py

@@ -0,0 +1,27 @@
+"""Transparent command forwarding; never resolves the bundled executable via PATH."""
+import os
+import subprocess
+import sys
+from .client import binary_path, CoolooError, _stop
+
+
+def main() -> int:
+    try:
+        args = [str(binary_path()), *sys.argv[1:]]
+        if os.name != "nt":
+            os.execv(args[0], args)
+        # Explicit handles preserve redirected streams through the Python launcher.
+        proc = subprocess.Popen(args, stdin=sys.stdin, stdout=sys.stdout, stderr=sys.stderr)
+        try:
+            return proc.wait()
+        except KeyboardInterrupt:
+            _stop(proc)
+            return 130
+    except (CoolooError, OSError) as exc:
+        print(f"cooloo: {exc}", file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

cooloo-0.1.0.dist-info/METADATA

@@ -0,0 +1,99 @@
+Metadata-Version: 2.4
+Name: cooloo
+Version: 0.1.0
+Summary: Python API and launcher for the cooloo GUI and CLI client
+Author: cooloo contributors
+License-Expression: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# cooloo Python API and GUI launcher — 0.1.0
+
+Thin wrapper around the bundled C GUI+CLI client (0.2.3, JSONL schema 1).
+No Python Native/Noise implementation, SSH backend, daemon, or CLI-only distribution.
+Initial wheels target Windows x86_64 and macOS arm64. Python >=3.10.
+Licensed under MIT; bundled third-party components retain their own licenses.
+
+## Installation / launch (after publication)
+
+```sh
+pip install cooloo
+pipx install cooloo
+cooloo --gui
+# Or without a persistent pipx installation:
+pipx run --spec cooloo cooloo --gui
+```
+
+`cooloo` with no arguments also opens the GUI. Other commands are forwarded unchanged.
+Unsigned/not notarized native artifacts retain their platform trust limitations.
+No runtime downloads, PATH lookup, implicit identity creation or registration.
+Unsupported platforms have no matching wheel; source users may explicitly supply a
+compatible local C executable. No source distribution is published in this first release.
+
+## Python usage
+
+```python
+from cooloo import Client
+
+client = Client(host="your-server:4222", config_dir="./bot-identity")
+# client.keygen()                       # once, explicitly
+# Client(..., tofu=True).register("bot") # explicitly trust first server connection
+end = client.send("<destination-id>", "hello\n世界")
+with client.read("<destination-id>", offset=0) as messages:
+    for message in messages:
+        print(message.sender, message.content, message.end_offset)
+
+with client.follow("<destination-id>", offset=saved_offset) as messages:
+    for message in messages:
+        process(message)
+        save_checkpoint(message.end_offset)  # only AFTER business processing
+```
+
+Replace example IDs, server, and application functions. Obtain/trust the server pin through
+an appropriate trusted channel; `tofu=True` is an explicit first-use trust decision, not
+protection from a first-connection MITM. Changed stored pins always fail. Config defaults
+match native CLI (`~/.cooloo`); use a separate directory per service/credential. Parent
+of a new config directory must exist. Private identity files must not be shared/logged.
+
+Methods: keygen, register, whoami, rooms, create_room, meta, rename, avatar, send,
+read, follow, sent, join, approve_join, set_room_mode, delegate. Pass
+`effective_identity=owner_id` to select an explicitly delegated identity; failed AS
+never falls back to login identity. Administrative operations require actual owner
+credentials. `sent(peer, offset=...)` returns SentResult(messages, scan_offset), including
+an advanced cursor on empty filtered results. SENT never populates normal message caches.
+Private rooms currently permit any registered user to make them public: **not a
+confidentiality guarantee**. No aggregate history or complete multi-device recovery.
+
+Each call starts a process and authenticates a connection. `timeout=30` bounds finite
+commands. FOLLOW has no overall timeout; optional idle_timeout bounds silence. It may
+end when the server closes an idle connection; no automatic reconnect, keepalive or retry.
+Context managers close streams and reap subprocesses; **always close streams on early
+exit**, including breaks. GUI caches are untouched by machine READ/FOLLOW. No exactly-once
+claim: replay can occur; deduplicate by destination/end_offset and persist business cursors.
+
+CoolooError exposes code/message. SendOutcomeUnknown means delivery may have happened;
+never blindly retry. A valid server acknowledgement returns end_offset. No guarantees of
+thread-safe shared Client usage. No shell execution; SEND uses UTF-8 stdin, max 4096 bytes.
+
+## Development and packaging
+
+```sh
+PYTHONPATH=src python -m unittest discover -s tests -v
+```
+
+Integration tests need sibling `client/cooloo-cli` and `server/coolood`, or explicit test
+binary overrides; all connections use temporary identities and loopback servers.
+This CLI-only build is a local test fixture, not the distributed product.
+
+Build each platform from a separate package source copy: stage its verified GUI+CLI
+artifact with tools/stage_binary.py, then `python -m build --wheel`. The builder refuses
+missing artifacts, changed hashes, and source distributions. macOS wheel tag must match
+the actual deployment target; do not infer it from the build host version. Keep the
+manifest's source commit/version/hash with the binary. The bundle must include third-party
+license notices and the C client's MIT license before public distribution.
+See [LICENSE](LICENSE) for the Python SDK's MIT license.
+
+Source repository: https://github.com/cooloo-app/python-sdk . The planner includes it as
+`python-sdk/` submodule; package name and Python import remain `cooloo`.

cooloo-0.1.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+cooloo-0.1.0.data/purelib/cooloo/__init__.py,sha256=kqhMsLudG3jtGDxhKp77ZbggOsk7Em7vOUlLbtECPGw,289
+cooloo-0.1.0.data/purelib/cooloo/client.py,sha256=szY1ZNxNC10R0pqUm8jhxLGdyewsn1_CO0qQ2IK2nLA,13993
+cooloo-0.1.0.data/purelib/cooloo/launcher.py,sha256=nj1AL_PNgJldMiJMKzRKr5C0Dn_UHzokXzrwQWOtgkQ,803
+cooloo-0.1.0.data/purelib/cooloo/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cooloo-0.1.0.data/purelib/cooloo/_bin/cooloo.exe,sha256=GQeexsVZ61jF3axoB2abpRs0-oMBAyRs2uADt2E_woo,4161497
+cooloo-0.1.0.data/purelib/cooloo/_bin/manifest.json,sha256=iflB9gHFDFD57zPr97y4mWRZFt8uwpGUv37S6-iLXhQ,227
+cooloo-0.1.0.data/purelib/cooloo/_licenses/JetBrainsMono.txt,sha256=PV-7LQ6DkZyNnGqnow6VVO80SLAnD1KnUg1JzJ_6WI8,4492
+cooloo-0.1.0.data/purelib/cooloo/_licenses/Lua.txt,sha256=1lt9iPvOQOsSEbrI5b1OVkLyLmqqqGzn4KBrPKL5DFg,1272
+cooloo-0.1.0.data/purelib/cooloo/_licenses/Monocypher.txt,sha256=qj1GVxNp3cAGTRiTpLTrl5EwZtxB68aXsCwdfBmTPGM,2401
+cooloo-0.1.0.data/purelib/cooloo/_licenses/SDL.txt,sha256=a42od_UYuuPiYbJhN1TMl-kW8gABxUmbTOpmgKxtHhs,902
+cooloo-0.1.0.data/purelib/cooloo/_licenses/cooloo-client-MIT.txt,sha256=JY1ueC0hOGNyMPJ_-QpIeJNCW-1f4VZKJG9FWUDnACo,1076
+cooloo-0.1.0.data/purelib/cooloo/_licenses/stb_truetype.txt,sha256=Mj6sZoxCIgPzxUok4Hf9LpmaxteawYcuYZgwyzvLNP4,2437
+cooloo-0.1.0.dist-info/licenses/LICENSE,sha256=JY1ueC0hOGNyMPJ_-QpIeJNCW-1f4VZKJG9FWUDnACo,1076
+cooloo-0.1.0.dist-info/METADATA,sha256=XSvw4frQm22CSDMASknnWRpbLBQJ0s72SIlVLpmggKM,4925
+cooloo-0.1.0.dist-info/WHEEL,sha256=GjDPPQwEcripVP6P2r3RxLa-h5Lb9ifGB7FYYtbLDT0,98
+cooloo-0.1.0.dist-info/entry_points.txt,sha256=NEIIivBmhBaxCNIna5IQWzD1uEbvpOCrgEA_nt7HzoM,48
+cooloo-0.1.0.dist-info/top_level.txt,sha256=aY-6iDoTkzKFAu2BPS1IxrqZLBvq1SOtW2ZNYv9scwI,7
+cooloo-0.1.0.dist-info/RECORD,,

cooloo-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: false
+Tag: py3-none-win_amd64
+

cooloo-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cooloo = cooloo.launcher:main

cooloo-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 cooloo contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cooloo-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+cooloo