FIX SOME BUGS

test_e2e.py

@@ -0,0 +1,129 @@
+#!/usr/bin/env python3
+"""End-to-end test: fake ollama -> real daemon -> real client agent loop.
+
+Exercises the whole chain the same way a user would: the client connects,
+logs in, gets a task, confirms a shell command, and the agent actually
+creates a file in the working directory.
+
+Run:  python3 test_e2e.py
+"""
+import json
+import os
+import shutil
+import socket
+import subprocess
+import sys
+import tempfile
+import time
+import unittest
+import urllib.request
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent
+
+
+def free_ports(count: int) -> list[int]:
+    """Find unused ports by binding ephemeral sockets (avoids TIME_WAIT)."""
+    ports, sockets = [], []
+    while len(ports) < count:
+        s = socket.socket()
+        s.bind(("127.0.0.1", 0))
+        sockets.append(s)
+        ports.append(s.getsockname()[1])
+    for s in sockets:
+        s.close()
+    return ports
+
+
+class E2E(unittest.TestCase):
+    def setUp(self):
+        self.ollama_port, self.daemon_port = free_ports(2)
+        self.tmp = Path(tempfile.mkdtemp(prefix="sj-e2e-"))
+        self.server_dir = self.tmp / "server"
+        self.work = self.tmp / "work"
+        self.server_dir.mkdir()
+        self.work.mkdir()
+        (self.server_dir / "config.toml").write_text(
+            f'[server]\nhost = "127.0.0.1"\nport = {self.daemon_port}\n'
+            f'\n[ollama]\nbase_url = "http://127.0.0.1:{self.ollama_port}"\n'
+            'model = "fake-model"\nnum_ctx = 16384\n'
+            '\n[database]\npath = "sjcode.db"\n'
+            "\n[limits]\nuser = 120\nadmin = -1\n"
+        )
+        self.prompt_log = self.tmp / "prompts.log"
+
+        self.fake = subprocess.Popen(
+            [sys.executable, str(ROOT / "fake_ollama.py"),
+             str(self.ollama_port), str(self.prompt_log)],
+            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        env = dict(os.environ, SJCODE_CONFIG=str(self.server_dir / "config.toml"))
+        self.daemon = subprocess.Popen(
+            [sys.executable, str(ROOT / "server" / "server.py")],
+            cwd=self.server_dir, env=env, stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
+        self._wait_ready()
+        # create the test account through the daemon admin CLI
+        self.daemon.stdin.write("create tester admin\nsecret\nsecret\n")
+        self.daemon.stdin.flush()
+        time.sleep(0.5)  # let the admin CLI process the lines
+
+    def _wait_ready(self, timeout: float = 10.0) -> None:
+        deadline = time.time() + timeout
+        url = f"http://127.0.0.1:{self.daemon_port}/status"
+        while time.time() < deadline:
+            try:
+                with urllib.request.urlopen(url, timeout=2) as resp:
+                    if resp.status == 200:
+                        return
+            except OSError:
+                time.sleep(0.1)
+        self.fail("daemon did not come up in time")
+
+    def tearDown(self):
+        for proc in (self.daemon, self.fake):
+            if proc.poll() is None:
+                proc.terminate()
+        for proc in (self.daemon, self.fake):
+            try:
+                proc.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                proc.kill()
+        shutil.rmtree(self.tmp, ignore_errors=True)
+
+    def _client_run(self, inputs: list[str]) -> subprocess.CompletedProcess:
+        script = "\n".join(inputs) + "\n"
+        # keep the client's saved-server config inside the test sandbox
+        env = dict(os.environ, XDG_CONFIG_HOME=str(self.tmp / "cfg"))
+        return subprocess.run(
+            [sys.executable, str(ROOT / "client.py"),
+             f"127.0.0.1:{self.daemon_port}", "--model", "fake-model"],
+            cwd=self.work, env=env, input=script, capture_output=True,
+            text=True, timeout=120)
+
+    def test_full_agent_run_with_confirmation(self):
+        proc = self._client_run([
+            "tester",     # username
+            "secret",     # password
+            "create hello.txt with the word hi in it",
+            "y",          # confirm the run tool call
+            "/quit",
+        ])
+        self.assertEqual(proc.returncode, 0, proc.stdout + proc.stderr)
+        self.assertIn("logged in as tester", proc.stdout)
+        self.assertIn("Done.", proc.stdout)
+
+        hello = self.work / "hello.txt"
+        self.assertTrue(hello.exists(), "agent did not create hello.txt")
+        self.assertEqual(hello.read_text().strip(), "hi")
+
+        # the model saw the REAL command output, not invented text
+        prompts = [json.loads(line)
+                   for line in self.prompt_log.read_text().splitlines()]
+        self.assertEqual(len(prompts), 4)  # run, read, done, done-again
+        self.assertIn("printf", prompts[1])          # run result fed back
+        self.assertIn("Tool results", prompts[1])
+        self.assertIn("1\thi", prompts[2])           # read result fed back
+
+
+if __name__ == "__main__":
+    unittest.main()