stcode 0.0.1a1__tar.gz → 0.0.1a2__tar.gz

{stcode-0.0.1a1 → stcode-0.0.1a2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: stcode
-Version: 0.0.1a1
+Version: 0.0.1a2
 Summary: A coding agent that lives in a daemon, and a UI that is a client of it.
 Project-URL: Homepage, https://ming-doan.github.io/stcode/
 Project-URL: Documentation, https://ming-doan.github.io/stcode/docs/

{stcode-0.0.1a1 → stcode-0.0.1a2}/docs/architecture/configuration.md

@@ -127,14 +127,14 @@ project) and `keep`, the number of session files `prune` leaves behind.
 
 | Key | Default | |
 | --- | --- | --- |
-| `transport` | `"unix"` | `unix` on your machine, `tcp` in a container |
+| `transport` | `"unix"` on Unix, `"tcp"` on Windows | `tcp` also works in a container |
 | `socket` | `~/.stcode/daemon.sock` | `unix` only |
 | `host` / `port` | `127.0.0.1` / `7717` | `tcp` only |
 | `max_clients` | *unset* | concurrent connections. **Unset = 1 in a container, unlimited on the host**; `0` is unlimited everywhere |
 
-Read by the daemon only. The UI connects to `~/.stcode/daemon.sock` unless given
-`--socket` or `--transport tcp --host --port`, and starts the daemon on that same
-address. → [daemon.md](daemon.md#one-client-in-a-container)
+Read by the daemon only. The UI connects to `~/.stcode/daemon.sock` on Unix or
+`127.0.0.1:7717` over TCP on Windows unless given address flags, and starts the daemon
+on that same address. → [daemon.md](daemon.md#one-client-in-a-container)
 
 ### `[mcp]`
 

{stcode-0.0.1a1 → stcode-0.0.1a2}/docs/architecture/daemon.md

@@ -41,9 +41,10 @@ stcode --daemonless   # the UI alone, attached to a daemon elsewhere
 ```
 
 No implementation switches between them. `--headless` replaces the `stcode` process
-with `stcode-daemon`. Plain `stcode` connects to `~/.stcode/daemon.sock` (or the address
-its flags name); if nothing answers, `cli/services/launcher.py` starts `stcode-daemon` on that
-address as a subprocess, logging to `~/.stcode/daemon.log`, and stops it again when the
+with `stcode-daemon`. Plain `stcode` connects to `~/.stcode/daemon.sock` on Unix or
+`127.0.0.1:7717` over TCP on Windows (or the address its flags name); if nothing answers,
+`cli/services/launcher.py` starts `stcode-daemon` on that address as a subprocess,
+logging to `daemon.log` in the stcode home directory, and stops it again when the
 UI exits. A daemon it *found* is left running — quitting is a detach. `stcode --restart`
 sends `shutdown` to whatever is listening first, for a daemon that is wedged or running
 old code.
@@ -260,17 +261,24 @@ the container is the mitigation.
 
 ```toml
 [daemon]
-transport = "unix"            # "tcp" inside a container
+# transport = "unix"          # default on Unix; "tcp" on Windows
 socket    = "~/.stcode/daemon.sock"
 host      = "127.0.0.1"
 port      = 7717
 ```
 
-`unix` for solo — no port to collide with, and filesystem permissions are the access
-control (the socket is chmod 0600; anyone who can open it can drive an agent with your
+`unix` for solo on Unix — no port to collide with, and filesystem permissions are the
+access control (the socket is chmod 0600; anyone who can open it can drive an agent with your
 privileges). `tcp` for a container, which has no host filesystem to put a socket on. Same
 JSONL framing either way, so a WebSocket adapter later is an adapter, not a protocol.
 
+Both the client and daemon default to loopback TCP when asyncio's Unix socket APIs
+are unavailable, as on Windows. Explicitly requesting `unix` on such a platform
+reports an unsupported transport with a hint to use `--transport tcp`.
+On Windows, set provider keys in the daemon's config file or environment: TCP still
+refuses API key updates and protocol shutdown, including `--restart` of a running
+daemon. The launcher can stop a daemon it started when the UI exits.
+
 **Transport is configuration, not architecture.** The one thing that reads it is
 `Daemon.local_only`, which decides what only this machine's user may do — send a key,
 stop the daemon. Anything else that needs to know is in the wrong layer.

{stcode-0.0.1a1 → stcode-0.0.1a2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "stcode"
-version = "0.0.1a1"
+version = "0.0.1a2"
 description = "A coding agent that lives in a daemon, and a UI that is a client of it."
 readme = "README.md"
 requires-python = ">=3.10"

{stcode-0.0.1a1 → stcode-0.0.1a2}/stcode/cli/main.py

@@ -178,7 +178,9 @@ def main(
 def _address(
     transport: str | None, socket: str | None, host: str | None, port: int | None
 ) -> Address:
-    address = Address(transport=transport or "unix")
+    address = Address()
+    if transport:
+        address.transport = transport
     if socket:
         address.socket = Path(socket).expanduser()
     address.host = host or address.host

{stcode-0.0.1a1 → stcode-0.0.1a2}/stcode/cli/services/client.py

@@ -44,7 +44,9 @@ rather than hung on."""
 class Address:
     """Where a daemon listens."""
 
-    transport: str = "unix"
+    transport: str = field(
+        default_factory=lambda: "unix" if hasattr(asyncio, "open_unix_connection") else "tcp"
+    )
     socket: Path = field(default_factory=lambda: stcode_home() / "daemon.sock")
     host: str = "127.0.0.1"
     port: int = 7717
@@ -91,6 +93,10 @@ class DaemonClient:
         """Open the transport. `OSError` when nothing is listening — the caller's cue to
         start a daemon or ask for another address, not an error to hide."""
         if address.transport == "unix":
+            if not hasattr(asyncio, "open_unix_connection"):
+                raise OSError(
+                    "Unix sockets are unavailable on this platform; use --transport tcp."
+                )
             reader, writer = await asyncio.open_unix_connection(
                 str(address.socket.expanduser()), limit=STREAM_LIMIT
             )

{stcode-0.0.1a1 → stcode-0.0.1a2}/stcode/core/configs.py

@@ -17,6 +17,7 @@ A leaf: imports nothing from `stcode`, so anything in `core/` may import it.
 
 from __future__ import annotations
 
+import asyncio
 import os
 import re
 from pathlib import Path
@@ -103,13 +104,16 @@ class DaemonConfig(BaseModel):
     """Where the daemon listens.
     Args:
         transport: `unix` — socket via `socket` path, `tcp` — socket via `host` and `port`.
+            Defaults to `tcp` when asyncio has no Unix socket support (Windows).
         socket: Path to the Unix socket file. Ignored if `transport` is `tcp`.
         host: Hostname to bind to. Ignored if `transport` is `unix`.
         port: Port to bind to. Ignored if `transport` is `unix`.
         max_clients: How many clients may be connected at once. 0 = unlimited. Unset =
             1 in a container, unlimited on the host.
     """
-    transport: Literal["unix", "tcp"] = "unix"
+    transport: Literal["unix", "tcp"] = Field(
+        default_factory=lambda: "unix" if hasattr(asyncio, "start_unix_server") else "tcp"
+    )
     socket: Path = Field(default_factory=lambda: home_dir() / "daemon.sock")
     host: str = "127.0.0.1"
     port: int = 7717

{stcode-0.0.1a1 → stcode-0.0.1a2}/stcode/core/daemon/server.py

@@ -155,6 +155,10 @@ class Daemon:
 
         settings = self.config.daemon
         if settings.transport == "unix":
+            if not hasattr(asyncio, "start_unix_server"):
+                raise OSError(
+                    "Unix sockets are unavailable on this platform; use --transport tcp."
+                )
             path = socket_path(settings.socket)
             path.parent.mkdir(parents=True, exist_ok=True)
             _clear_stale_socket(path)

{stcode-0.0.1a1 → stcode-0.0.1a2}/stcode.example.toml

@@ -63,11 +63,11 @@ difficulty = "high"
 # dir = "./.stcode/sessions"
 # keep = 100
 
-# Where the daemon listens. `unix` on your own machine, `tcp` inside a container.
-# The UI does not read this: it connects to ~/.stcode/daemon.sock unless told otherwise
-# with --socket / --transport tcp --host --port, and starts the daemon on that address.
+# Where the daemon listens. Default: `unix` on Unix, loopback `tcp` on Windows.
+# Use `tcp` inside a container. The UI does not read this: it uses the same platform
+# default unless given --transport / --socket / --host / --port flags.
 [daemon]
-transport = "unix"
+# transport = "unix"     # use "tcp" on Windows or inside a container
 # socket = "~/.stcode/daemon.sock"
 # host = "0.0.0.0"       # when transport = "tcp"
 # port = 7717

stcode-0.0.1a2/tests/integration/transport_test.py

@@ -0,0 +1,96 @@
+"""Platform transport defaults must agree without requiring Unix-only asyncio APIs."""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+
+import pytest
+from driving import asynctest
+
+from stcode.cli.main import _address
+from stcode.cli.services.client import Address, DaemonClient
+from stcode.core.configs import Config, load_config
+from stcode.core.daemon import Daemon
+
+
+@pytest.fixture
+def without_unix_sockets(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Match Windows' asyncio surface while still using real TCP sockets."""
+    monkeypatch.delattr(asyncio, "open_unix_connection", raising=False)
+    monkeypatch.delattr(asyncio, "start_unix_server", raising=False)
+
+
+@pytest.mark.skipif(
+    not hasattr(asyncio, "open_unix_connection")
+    or not hasattr(asyncio, "start_unix_server"),
+    reason="Unix socket APIs are unavailable",
+)
+def test_unix_remains_the_default_where_supported() -> None:
+    assert Address().transport == "unix"
+    assert _address(None, None, None, None).transport == "unix"
+    assert Config().daemon.transport == "unix"
+    assert _address("tcp", None, "127.0.0.1", 9000).daemon_args() == [
+        "--transport", "tcp", "--host", "127.0.0.1", "--port", "9000",
+    ]
+
+
+@asynctest
+async def test_defaults_connect_over_tcp_without_unix_apis(
+    tmp_path: Path, without_unix_sockets: None,
+) -> None:
+    address = _address(None, None, None, None)
+    assert address.transport == Address().transport == "tcp"
+    assert str(address) == "127.0.0.1:7717"
+    assert address.daemon_args() == [
+        "--transport", "tcp", "--host", "127.0.0.1", "--port", "7717",
+    ]
+
+    path = tmp_path / "config.toml"
+    config = load_config(
+        path,
+        create_if_missing=True,
+        overrides={"session.dir": str(tmp_path / "sessions"), "daemon.port": 0},
+    )
+    assert config.daemon.transport == "tcp"
+    assert load_config(path).daemon.transport == "tcp"
+    assert config.daemon.host == address.host
+
+    async with Daemon(config) as daemon:
+        assert daemon._server is not None
+        address.port = daemon._server.sockets[0].getsockname()[1]
+        async with await DaemonClient.connect(address) as client:
+            frame = await client.get_config()
+            assert frame["path"] == str(path)
+            assert frame["keys_editable"] is False
+            assert await client.sessions() == []
+
+
+@asynctest
+async def test_explicit_unix_client_reports_how_to_use_tcp(
+    tmp_path: Path, without_unix_sockets: None,
+) -> None:
+    address = _address("unix", str(tmp_path / "d.sock"), None, None)
+    assert address.transport == "unix"
+    with pytest.raises(OSError, match="Unix sockets.*--transport tcp"):
+        await DaemonClient.connect(address)
+
+
+@asynctest
+async def test_explicit_unix_daemon_reports_how_to_use_tcp(
+    tmp_path: Path, without_unix_sockets: None,
+) -> None:
+    config = load_config(
+        tmp_path / "config.toml",
+        create_if_missing=True,
+        overrides={
+            "daemon.transport": "unix",
+            "daemon.socket": str(tmp_path / "d.sock"),
+            "session.dir": str(tmp_path / "sessions"),
+        },
+    )
+    assert config.daemon.transport == "unix"
+    with pytest.raises(OSError, match="Unix sockets.*--transport tcp"):
+        async with Daemon(config):
+            pass
+    assert not config.daemon.socket.exists()

{stcode-0.0.1a1 → stcode-0.0.1a2}/uv.lock

@@ -3289,7 +3289,7 @@ wheels = [
 
 [[package]]
 name = "stcode"
-version = "0.0.1a1"
+version = "0.0.1a2"
 source = { editable = "." }
 dependencies = [
     { name = "anthropic" },