monkeypatch.setenv("SHELLDECK_HOME", str(tmp_path))

monkeypatch.setattr(server, "ALLOWED_HOSTS", {"testserver"})

with TestClient(server.app) as c:

c.headers["X-Shelldeck-Token"] = auth.read_cli_token() # act as the host CLI

"""A client with no CLI token: it must log in like a browser."""

auth._failures.clear()

monkeypatch.setitem(server._active, "h", None)

monkeypatch.setenv("SHELLDECK_HOME", str(tmp_path))

monkeypatch.setattr(server, "ALLOWED_HOSTS", {"testserver"})

with TestClient(server.app) as c:

sb = Scrollback(limit=10)

for chunk in ("abcd", "efgh", "ijkl"):

sb.add(chunk)

assert sb.text() == "cdefghijkl"

sb.add("x" * 25)

m = PtyManager(store=tmp_path)

m.scrollback["abc123"] = sb = Scrollback()

sb.add("hello from before\r\n")

m.save()

back = PtyManager(store=tmp_path)._restore("abc123")

assert back.restored == "hello from before\r\n" and back.restored_at and back.text() == "" # CRLF kept, not in the live stream

assert back.persisted() == "hello from before\r\n" # kept for the next restart until a snapshot replaces it

assert PtyManager(store=tmp_path)._restore("../evil").restored == ""

m.snapshot("abc123", "rendered screen")

assert sb.persisted() == "rendered screen"

sb.add("x" * 5000) # lots of output since the snapshot: fall back to raw

assert sb.persisted().endswith("x" * 5000)

m.prune(keep={"other"})

import os

from shelldeck import stats

r = stats.collect({"me": os.getpid(), "gone": 2**22 + 7})

assert r["sessions"]["me"]["mem"] > 0 and r["sessions"]["me"]["procs"] >= 1

assert "gone" not in r["sessions"]

s = client.get("/api/stats").json()

import os

import subprocess

import sys

from shelldeck import agents, stats

# a node/python-installed agent is found by its package path, with the --model it was given

child = subprocess.Popen([sys.executable, "-c", "import time; time.sleep(30)", "@anthropic-ai/claude-code", "--model", "opus"])

try:

time.sleep(0.5)

agents._ppids["at"] = 0 # the shared process snapshot may predate the child

assert agents.running({"me": os.getpid()}) == {"me": ("claude", "opus")}

assert stats.collect({"me": os.getpid()})["sessions"]["me"]["agent"] == {"key": "claude", "label": "Claude Code", "model": "opus", "context": None}

finally:

child.kill()

data = client.get("/api/agents").json()

assert data["running"] == [] and {"claude", "codex", "devin"} <= {a["key"] for a in data["agents"]}

assert isinstance(data["outside"], list) and isinstance(data["devin_sessions"], list)

integrations = {item["agent"]: item for item in client.get("/api/integrations").json()["integrations"]}

assert integrations["opencode"]["lifecycle"] is True

assert integrations["amp"]["session_restore"] is False

# Devin's session store: newest first, hidden ones skipped

import sqlite3

store = tmp_path / "devin" / "cli" / "sessions.db"

store.parent.mkdir(parents=True)

with sqlite3.connect(store) as conn:

conn.execute("CREATE TABLE sessions (id TEXT, working_directory TEXT, backend_type TEXT, model TEXT, "

"created_at INT, last_activity_at INT, title TEXT, hidden INT DEFAULT 0)")

conn.executemany("INSERT INTO sessions VALUES (?, ?, 'Windsurf', 'swe-1-6', 1, ?, ?, ?)",

[("old-one", "D:/a", 5, "Old", 0), ("new-one", "D:/b", 9, "New", 0), ("gone", "D:/c", 7, "Hidden", 1)])

conn.close()

monkeypatch.setenv("APPDATA", str(tmp_path))

assert [(d["id"], d["cwd"]) for d in agents.devin_sessions()] == [("new-one", "D:/b"), ("old-one", "D:/a")]

# peers read each other's screen and type into each other

sid = client.post("/api/sessions", json={"cwd": str(tmp_path)}).json()["id"]

server.manager.scrollback.setdefault(sid, Scrollback()).add("\x1b[32mworking on auth\x1b[0m\r\ndone\r\n\r\n")

assert client.get(f"/api/sessions/{sid}/screen", params={"lines": 1}).json()["text"] == "done"

assert client.get("/api/sessions/nope/screen").status_code == 404

assert client.post(f"/api/sessions/{sid}/input", json={"text": "hi"}).json()["error"] == "not_running"

"""Terminal nicks, sd spawn (without really starting a shell), hand-off files, done and orphaned hand-offs."""

from shelldeck import team

monkeypatch.setenv("CLAUDE_CONFIG_DIR", str(tmp_path / "claude-home"))

team._selfcheck() # tiers, model picks, spawn line, skill install

import yaml

assert yaml.safe_load(team.SKILL.split("---\n")[1])["name"] == "shelldeck" # bad frontmatter hides the skill

started = []

async def fake_start(sid, line):

started.append(line)

monkeypatch.setattr(server, "_attach", lambda *a: None)

monkeypatch.setattr(server, "_start_agent", fake_start)

a = client.post("/api/sessions", json={"cwd": str(tmp_path)}).json()

b = client.post("/api/sessions", json={"cwd": str(tmp_path)}).json()

assert a["nick"] and b["nick"] and a["nick"] != b["nick"]

assert client.post("/api/spawn", json={"parent": a["id"]}).json()["error"] == "task_required"

assert client.post("/api/spawn", json={"parent": a["id"], "task": "x", "agent": "aider"}).json()["error"] == "cannot_spawn:aider"

r = client.post("/api/spawn", json={"parent": a["id"], "task": "fix a typo in the readme", "agent": "claude", "model": "large"}).json()

kid, h = r["session"], r["handoff"]

assert kid["parent"] == a["id"] and r["model"] == "opus" and started == [r["command"]]

# per-run hooks ride on Claude's own --settings flag (no global hook installed in this test home)

assert r["command"].startswith("claude --model opus --settings ") and "claude-settings.json" in r["command"]

assert f'"You are {kid["nick"]}, a shelldeck sub-agent working for {a["nick"]}.' in r["command"]

task_file = tmp_path / ".shelldeck" / "handoffs" / f"{h['id']}.md"

assert "fix a typo in the readme" in task_file.read_text(encoding="utf-8")

assert (tmp_path / ".shelldeck" / ".gitignore").read_text() == "*\n"

# sub-agents can't spawn

assert client.post("/api/spawn", json={"parent": kid["id"], "task": "more"}).status_code == 403

# a hand-off needs an agent running in the target (typed text would run in a bare shell)

assert client.post("/api/handoffs", json={"to": b["id"], "task": "x"}).status_code == 409

done = client.post(f"/api/handoffs/{h['id']}/done", json={"result": "fixed it"}).json()

assert done["status"] == "done" and "fixed it" in task_file.read_text(encoding="utf-8")

assert client.post(f"/api/handoffs/{h['id']}/done", json={}).status_code == 409

assert "| done |" in (tmp_path / ".shelldeck" / "handoff.md").read_text(encoding="utf-8")

h2 = client.post("/api/spawn", json={"parent": a["id"], "task": "another"}).json()["handoff"]

assert [x["id"] for x in server._orphan(h2["to_sid"])] == [h2["id"]]

assert db.get_handoff(h2["id"])["status"] == "exited"

# the user cancels one from the page; hand-offs and how they ended are in the project's context

h3 = client.post("/api/spawn", json={"parent": a["id"], "task": "third"}).json()["handoff"]

assert client.post(f"/api/handoffs/{h3['id']}/done", json={"cancelled": True}).json()["status"] == "cancelled"

ctx = client.get("/api/context", params={"project": a["project_id"]}).json()

assert {"HANDOFF", "HANDOFF_DONE"} <= {e["type"] for e in ctx["recent_events"]}

assert f"HANDOFF_DONE by claude: {h['id']}" in ctx["text"] and "[done] fixed it" in ctx["text"]

# a sub-agent's question goes to its parent (here a plain shell, so it's broadcast to the user), once

import asyncio

sent = []

async def fake_broadcast(msg):

sent.append(msg)

return 0

monkeypatch.setattr(server, "_broadcast", fake_broadcast)

monkeypatch.setattr(server, "QUIET_S", 1e9) # keep the app's own watcher off these

server.ask_buf[kid["id"]] = "\x1b[2J\x1b[5;1HRead 1 file\r\n\x1b[20;1H Do you want to proceed?\r\n \x1b[1m1. Yes\x1b[0m 2. No"

server.ask_buf[b["id"]] = "just some output about approvals"

assert asyncio.run(server._check_questions(quiet=0)) == [kid["id"]]

assert sent[0]["type"] == "question" and sent[0]["nick"] == kid["nick"]

assert asyncio.run(server._check_questions(quiet=0)) == [] # nothing new drawn since

assert "Do you want to proceed? 1. Yes 2. No" in sent[0]["text"]

server.ask_buf[kid["id"]] = "\x1b[20;1H Do you want to proceed?\r\n 1. Yes 2. No"

assert asyncio.run(server._check_questions(quiet=0)) == [] # the same prompt redrawn

server.ask_buf.clear()

f = tmp_path / "notes.txt"

f.write_bytes(b"one\r\ntwo\r\n")

r = client.get("/api/fs/file", params={"path": str(f)}).json()

assert r["text"] == "one\ntwo\n" and r["crlf"] and not r["readonly"]

# saving keeps CRLF, and refuses when the file changed on disk since it was read

assert client.put("/api/fs/file", json={"path": str(f), "text": "uno\n", "mtime": r["mtime"], "crlf": True}).status_code == 200

assert f.read_bytes() == b"uno\r\n"

assert client.put("/api/fs/file", json={"path": str(f), "text": "stale", "mtime": r["mtime"]}).status_code == 409

new = client.get("/api/fs/file", params={"path": str(tmp_path / "new.md")}).json()

assert new["new"] and new["text"] == ""

(tmp_path / "bin.dat").write_bytes(b"\0\1\2")

assert client.get("/api/fs/file", params={"path": str(tmp_path / "bin.dat")}).json()["error"] == "binary_file"

(tmp_path / "x.svg").write_text("<svg onload=alert(1)>")

assert client.get("/api/fs/raw", params={"path": str(tmp_path / "x.svg")}).status_code == 415

assert client.post("/api/fs/show", json={"path": str(f)}).json() == {"delivered": 0}

n = client.post("/api/scratch", json={"body": "# Ideas"}).json()

assert client.put(f"/api/scratch/{n['id']}", json={"body": "# Ideas\nmore"}).status_code == 200

assert client.get("/api/scratch").json()["notes"][0]["body"] == "# Ideas\nmore"

client.delete(f"/api/scratch/{n['id']}")

assert client.get("/api/scratch").json()["notes"] == []

"""Context window use read from Claude Code's and Codex's own logs (this process plays the agent)."""

import json

import os

from pathlib import Path

from shelldeck import agents

monkeypatch.setattr(Path, "home", lambda: tmp_path)

agents._files.clear()

pid = os.getpid()

claude = tmp_path / ".claude"

(claude / "sessions").mkdir(parents=True)

(claude / "projects" / "D--x").mkdir(parents=True)

(claude / "sessions" / f"{pid}.json").write_text(json.dumps({"sessionId": "s1", "status": "idle"}))

usage = {"input_tokens": 10, "cache_creation_input_tokens": 1000, "cache_read_input_tokens": 49000, "output_tokens": 990}

lines = [

{"type": "assistant", "message": {"model": "claude-sonnet-4-6", "usage": usage}},

{"type": "assistant", "isSidechain": True, "message": {"model": "claude-haiku-4-5", "usage": {"input_tokens": 5}}},

{"type": "user", "message": {"content": "hi"}},

]

(claude / "projects" / "D--x" / "s1.jsonl").write_text("\n".join(json.dumps(x) for x in lines))

assert agents.context(pid, "claude") == {"used": 51000, "window": 200_000, "estimated": True, "state": "idle", "model": "claude-sonnet-4-6"}

assert agents.CLAUDE_1M.search("claude-opus-5-5") and not agents.CLAUDE_1M.search("claude-opus-4-6")

rollout = tmp_path / ".codex" / "sessions" / "2026" / "09" / "30" / "rollout-x.jsonl"

rollout.parent.mkdir(parents=True)

events = [

{"type": "session_meta", "payload": {"cwd": os.getcwd()}},

{"type": "event_msg", "payload": {"type": "task_started", "model_context_window": 258400}},

{"type": "event_msg", "payload": {"type": "token_count", "info": {"last_token_usage": {"total_tokens": 64600}}}},

]

rollout.write_text("\n".join(json.dumps(x) for x in events))

assert agents.context(pid, "codex") == {"used": 64600, "window": 258400}

(tmp_path / "src").mkdir()

(tmp_path / "src" / "app.py").write_text("x = 1\n")

(tmp_path / "evil.bat").write_text("echo")

sid = client.post("/api/sessions", json={"cwd": str(tmp_path)}).json()["id"]

# history: recorded over the socket, deduped per start time, searchable and filterable

with client.websocket_connect(f"/ws/{sid}") as ws:

for cmd, code in (("git status", 0), ("pytest -x", 1), ("pytest -x", 1)):

ws.send_json({"type": "command", "cmd": cmd, "exit": code, "ms": 1200, "at": f"2026-01-01T00:00:0{code}Z"})

ws.send_json({"type": "snapshot", "data": "hello\r\nerror: boom at src/app.py:3\r\n"})

rows = client.get("/api/history").json()["commands"]

assert [r["command"] for r in rows] == ["pytest -x", "git status"]

assert [r["command"] for r in client.get("/api/history", params={"failed": True}).json()["commands"]] == ["pytest -x"]

assert client.get("/api/history", params={"q": "stat"}).json()["commands"][0]["exit_code"] == 0

# search across terminals reads saved output

server.manager.scrollback.setdefault(sid, Scrollback()).add("hello\r\nerror: boom at src/app.py:3\r\n")

res = client.get("/api/search", params={"q": "BOOM"}).json()["results"]

assert res[0]["session_id"] == sid and "src/app.py:3" in res[0]["hits"][0]["text"]

# clickable paths: only existing files, relative to the terminal's folder

files = client.post("/api/fs/check", json={"session_id": sid, "paths": ["src/app.py", "nope.py", "../x"]}).json()["files"]

assert files == ["src/app.py"]

opened = []

monkeypatch.setattr(server.os, "startfile", opened.append, raising=False)

monkeypatch.setattr(server.subprocess, "Popen", lambda argv, **kw: opened.append(argv[-1]))

assert client.post("/api/open", json={"session_id": sid, "path": "src/app.py", "line": 3}).status_code == 200

assert opened[-1].startswith("vscode://file/") and opened[-1].endswith("src/app.py:3")

client.put("/api/settings", json={"editor": "system"})

assert client.post("/api/open", json={"session_id": sid, "path": "evil.bat"}).json()["error"] == "refusing_to_run_executable"

assert client.put("/api/settings", json={"editor": "vim"}).status_code == 400

monkeypatch.delenv("PROMPT", raising=False)

argv, env = shells.with_integration(["C:/x/pwsh.exe", "-NoLogo"])

assert argv[:4] == ["C:/x/pwsh.exe", "-NoLogo", "-NoExit", "-EncodedCommand"] and env == {}

argv, env = shells.with_integration(["/bin/bash", "--login", "-i"])

assert argv[1] == "--rcfile" and argv[2].endswith("integration/bash.sh") and env == {"SHELLDECK_LOGIN": "1"}

argv, env = shells.with_integration(["cmd.exe"])

assert "133;A" in env["PROMPT"] and env["PROMPT"].count("$P$G") == 1

argv = shells.interactive_argv("wsl", "Ubuntu", r"C:\src")

assert argv[1:] == ["-d", "Ubuntu", "--cd", r"C:\src"]

cmd = shells.command_argv("wsl", "ls", None, r"C:\src")

assert cmd[-4:] == ["--", "sh", "-lc", "ls"]

with pytest.raises(WebSocketDisconnect), client.websocket_connect("/ws/nope"):

pass

sid = client.post("/api/sessions", json={"cwd": str(tmp_path)}).json()["id"]

with pytest.raises(WebSocketDisconnect), client.websocket_connect(

f"/ws/{sid}", headers={"origin": "http://evil.com"}

):

assert client.get("/api/settings").json()["default_shell"] == shells.default_kind()

assert client.put("/api/settings", json={"default_shell": "nope"}).status_code == 400

assert client.put("/api/settings", json={"font_size": "99"}).status_code == 400

kind = shells.kinds()[-1]

r = client.put("/api/settings", json={"default_shell": kind, "font_size": "15"})

assert r.json()["default_shell"] == kind and r.json()["font_size"] == "15"

assert client.put("/api/settings", json={"terminal_theme": "nope"}).status_code == 400

assert client.put("/api/settings", json={"font_family": "x;}</style>"}).status_code == 400

r = client.put("/api/settings", json={"terminal_theme": "nord", "font_family": "JetBrains Mono"}).json()

(tmp_path / "app").mkdir()

assert client.post("/api/projects", json={"path": str(tmp_path / "missing")}).status_code == 400

p = client.post("/api/projects", json={"path": str(tmp_path / "app")}).json()

assert client.patch(f"/api/projects/{p['id']}", json={"name": "App"}).json()["name"] == "App"

assert "app" in client.get("/api/fs/dirs", params={"path": str(tmp_path)}).json()["dirs"]

projects = client.get("/api/projects").json()["projects"]

assert [x["name"] for x in projects] == ["App"]

assert projects[0]["has_git"] is False

for d in ("api", "web", "a//b"):

(tmp_path / d).mkdir(parents=True)

ws = tmp_path / "Shop.code-workspace"

# JSONC: comments, trailing commas, a `//` inside a string, a remote uri folder that is skipped

ws.write_text('{\n // the folders\n "folders": [{"path": "api"}, /* web */ {"path": "web",},'

' {"path": "a//b"}, {"uri": "vscode-remote://x/y"},],\n}', encoding="utf-8")

assert "Shop.code-workspace" in client.get("/api/fs/dirs", params={"path": str(tmp_path)}).json()["files"]

r = client.post("/api/workspaces/import", json={"path": str(ws)}).json()

assert r["workspace"] == "Shop" and [p["name"] for p in r["projects"]] == ["api", "web", "b"]

assert {p["workspace"] for p in client.get("/api/projects").json()["projects"]} == {"Shop"}

pid = r["projects"][0]["id"]

assert client.patch(f"/api/projects/{pid}", json={"workspace": " Back\tend "}).json()["workspace"] == "Back end"

assert client.patch(f"/api/projects/{pid}", json={"workspace": ""}).json()["workspace"] is None

(tmp_path / "x").mkdir()

assert client.post("/api/projects", json={"path": str(tmp_path / "x"), "workspace": "Ops"}).json()["workspace"] == "Ops"

assert client.post("/api/workspaces/import", json={"path": str(tmp_path / "x")}).status_code == 400

# Explorer's "Copy as path" quotes it; folders that are gone are reported, not fatal

(tmp_path / "q.code-workspace").write_text('{"folders": [{"path": "api"}, {"path": "gone"}]}')

r = client.post("/api/workspaces/import", json={"path": f'"{tmp_path / "q.code-workspace"}"'}).json()

assert r["workspace"] == "q" and r["skipped"] == ["gone"] and len(r["projects"]) == 1

assert client.post("/api/projects", json={"path": f'"{tmp_path / "x"}"'}).status_code == 200

(tmp_path / "bad.code-workspace").write_text("{nope")

assert client.post("/api/workspaces/import", json={"path": str(tmp_path / "bad.code-workspace")}).json()["error"] == "workspace_file_unreadable"

(tmp_path / "empty.code-workspace").write_text('{"folders": []}')

import os

import subprocess

repo = tmp_path / "repo"

repo.mkdir()

env = {**os.environ, "GIT_AUTHOR_NAME": "t", "GIT_AUTHOR_EMAIL": "t@t.com", "GIT_COMMITTER_NAME": "t", "GIT_COMMITTER_EMAIL": "t@t.com"}

for args in (["init", "-q", "-b", "main"], ["commit", "-q", "--allow-empty", "-m", "first"], ["branch", "feature"]):

subprocess.run(["git", *args], cwd=repo, check=True, capture_output=True, env=env)

p = client.post("/api/projects", json={"path": str(repo)}).json()

assert client.get("/api/projects").json()["projects"][0]["has_git"] is True

log = client.get(f"/api/projects/{p['id']}/git/log").json()

assert log["current_branch"] == "main"

assert log["commits"][0]["subject"] == "first"

assert client.post(f"/api/projects/{p['id']}/git/checkout", json={"ref": "feature"}).json()["status"] == "ok"

assert client.get(f"/api/projects/{p['id']}/git/log").json()["current_branch"] == "feature"

assert client.post(f"/api/projects/{p['id']}/git/checkout", json={"ref": "no-such"}).status_code == 400

assert client.post(f"/api/projects/{p['id']}/git/checkout", json={"ref": "--orphan=x"}).status_code == 400

empty = tmp_path / "empty"

subprocess.run(["git", "init", "-q", str(empty)], check=True, capture_output=True)

e = client.post("/api/projects", json={"path": str(empty)}).json()

b = client.post("/api/bookmarks", json={"name": "st", "command": "git status"}).json()

assert client.put(f"/api/bookmarks/{b['id']}", json={"name": "st", "command": "git st"}).json()["command"] == "git st"

assert client.post("/api/bookmarks", json={"name": ""}).status_code == 400

assert client.delete(f"/api/bookmarks/{b['id']}").status_code == 200

t = client.post("/api/tasks", json={"title": "ship", "reminder_at": "2020-01-01T00:00:00Z"}).json()

assert t["column"] == "backlog"

assert client.post("/api/tasks", json={"title": " "}).status_code == 400

assert client.post(f"/api/tasks/{t['id']}/move", json={"column": "doing"}).json()["column"] == "doing"

assert client.put(f"/api/tasks/{t['id']}", json={"priority": "high"}).json()["priority"] == "high"

assert [a["id"] for a in client.get("/api/tasks/alarms").json()["alarms"]] == [t["id"]] # reminder is due

assert client.post(f"/api/tasks/{t['id']}/ack").json()["reminder_acknowledged"] is True

assert client.get("/api/tasks/alarms").json()["alarms"] == []

assert client.delete(f"/api/tasks/{t['id']}").json() == {"status": "ok"}

p = client.post("/api/projects", json={"path": str(tmp_path)}).json()

job = {"name": "hi", "project_id": p["id"], "command": "echo hi", "cron": "0 3 * * *"}

assert client.post("/api/schedule/jobs", json={**job, "cron": "nope"}).status_code == 400

assert client.post("/api/schedule/jobs", json={**job, "project_id": "x"}).status_code == 404

j = client.post("/api/schedule/jobs", json=job).json()

assert j["enabled"] is True and j["next_run_on"]

assert client.post(f"/api/schedule/jobs/{j['id']}/toggle").json()["enabled"] is False

assert client.put(f"/api/schedule/jobs/{j['id']}", json={"cron": "*/5 * * * *"}).json()["cron"] == "*/5 * * * *"

assert client.get("/api/schedule/jobs/nope/runs").status_code == 404

assert client.delete(f"/api/schedule/jobs/{j['id']}").json() == {"status": "ok"}

from shelldeck import runner

p = client.post("/api/projects", json={"path": str(tmp_path)}).json()

r = runner.run_command(p["id"], "echo shelldeck-ok", timeout=60)

b = browser

# nothing works until a password exists; setup rules

assert b.get("/api/projects").json() == {"error": "setup_required"}

assert b.get("/api/auth/status").json()["setup_code_required"] is False # the test client counts as local

assert b.post("/api/auth/setup", json={"password": "short", "confirm": "short"}).json()["error"] == "password_too_short"

assert b.post("/api/auth/setup", json={"password": "longenough", "confirm": "different"}).json()["error"] == "passwords_do_not_match"

r = b.post("/api/auth/setup", json={"password": "longenough", "confirm": "longenough"})

assert r.status_code == 200 and "httponly" in r.headers["set-cookie"].lower() and "samesite=strict" in r.headers["set-cookie"].lower()

assert b.get("/api/projects").status_code == 200

assert b.post("/api/auth/setup", json={"password": "x" * 9, "confirm": "x" * 9}).status_code == 409

# logout locks this browser; wrong password is refused; right one logs in

b.post("/api/auth/logout")

assert b.get("/api/projects").json() == {"error": "locked"}

assert b.post("/api/auth/login", json={"password": "nope"}).status_code == 401

assert b.post("/api/auth/login", json={"password": "longenough"}).status_code == 200

# change needs the current password + matching confirm, and signs out other browsers

other = TestClient(server.app)

other.post("/api/auth/login", json={"password": "longenough"})

assert other.get("/api/projects").status_code == 200

assert b.put("/api/auth/password", json={"current": "bad", "password": "newpassword", "confirm": "newpassword"}).status_code == 403

assert b.put("/api/auth/password", json={"current": "longenough", "password": "newpassword", "confirm": "typo"}).json()["error"] == "passwords_do_not_match"

assert b.put("/api/auth/password", json={"current": "longenough", "password": "newpassword", "confirm": "newpassword"}).status_code == 200

assert b.get("/api/projects").status_code == 200

auth._cache.clear()

assert other.get("/api/projects").status_code == 401

# the CLI token is not a browser login: it can't change the password

assert b.put("/api/auth/password", headers={"cookie": "", "X-Shelldeck-Token": auth.read_cli_token()},

json={"current": "newpassword", "password": "x" * 9, "confirm": "x" * 9}).status_code == 401

# emergency reset on the host: password and logins gone, remote setup needs the new code

code = auth.reset()

assert b.get("/api/projects").json() == {"error": "setup_required"}

monkeypatch.setattr(server, "_is_local", lambda conn: False)

assert b.post("/api/auth/setup", json={"password": "x" * 9, "confirm": "x" * 9, "code": "wrong"}).status_code == 403

"""Set once: the password file outlives a lost database row, and 0.0.4's database copy is migrated."""

monkeypatch.setenv("SHELLDECK_HOME", str(tmp_path))

db.init_db()

auth.set_password("longenough")

db.delete_setting(auth._PASSWORD_KEY) # the row an unclean shutdown lost

assert auth.init_auth() is None and auth.check_password("longenough")

(tmp_path / "password").unlink()

db.set_setting(auth._PASSWORD_KEY, auth._hash_password("fromolder1")) # only an old version's copy

auth.init_auth()

assert auth.check_password("fromolder1")

auth.reset()

b = browser

b.post("/api/auth/setup", json={"password": "longenough", "confirm": "longenough"})

b.post("/api/auth/logout")

codes = [b.post("/api/auth/login", json={"password": f"bad{i}"}).status_code for i in range(7)]

assert codes[:5] == [401] * 5 and 429 in codes[5:]

# host CLI login link: one use, then expired; browsers can't mint one

assert b.post("/api/auth/login-link").status_code == 403

path = b.post("/api/auth/login-link", headers={"X-Shelldeck-Token": auth.read_cli_token()}).json()["path"]

r = b.get(path, follow_redirects=False)

assert r.status_code == 303 and auth.COOKIE in r.headers["set-cookie"]

b = browser

b.post("/api/auth/setup", json={"password": "longenough", "confirm": "longenough"})

sid = b.post("/api/sessions", json={"cwd": str(tmp_path)}).json()["id"]

with b.websocket_connect(f"/ws/{sid}") as ws:

ws.send_json({"type": "ping"})

assert ws.receive_json() == {"type": "pong"}

b.post("/api/auth/logout")

with pytest.raises(WebSocketDisconnect), b.websocket_connect(f"/ws/{sid}"):

shell = "cmd" if shells.WINDOWS else "sh"

sid = client.post("/api/sessions", json={"cwd": str(tmp_path), "shell": shell}).json()["id"]

def read_until(ws, needle):

buf = ""

deadline = time.time() + 15

while needle not in buf and time.time() < deadline:

msg = ws.receive_json()

buf += msg.get("data", "")

return buf

with client.websocket_connect(f"/ws/{sid}") as ws:

ws.send_json({"type": "resize", "rows": 24, "cols": 80})

ws.send_json({"type": "input", "data": "echo shelldeck-ok\r\n"})

assert "shelldeck-ok" in read_until(ws, "shelldeck-ok\r\n")

if shells.WINDOWS: # cmd reports its directory through shell integration

(tmp_path / "sub").mkdir()

ws.send_json({"type": "input", "data": "cd sub\r\n"})

read_until(ws, f"Cwd={tmp_path / 'sub'}")

assert db.get_session(sid)["cwd"] == str(tmp_path / "sub")

# reconnect: scrollback replays earlier output

with client.websocket_connect(f"/ws/{sid}") as ws:

assert "shelldeck-ok" in ws.receive_json()["data"]

p = client.post("/api/projects", json={"path": str(tmp_path)}).json()

a, b = shells.kinds()[:2]

names = [client.post("/api/sessions", json={"project_id": p["id"], "shell": k}).json()["name"] for k in (a, a, b)]

assert names == [f"{shells.label(a)} 1", f"{shells.label(a)} 2", f"{shells.label(b)} 1"]

from shelldeck import cli

seen = []

monkeypatch.setattr(cli, "app", lambda: seen.append(list(cli.sys.argv)))

for argv, want in (

(["shelldeck", "C:/src"], ["shelldeck", "open", "C:/src"]),

(["shelldeck", "-p", "5500", "."], ["shelldeck", "-p", "5500", "open", "."]),

(["shelldeck", "list"], ["shelldeck", "list"]),

(["shelldeck", "login-link"], ["shelldeck", "login-link"]),

(["shelldeck"], ["shelldeck"]),

):

monkeypatch.setattr(cli.sys, "argv", list(argv))

cli._main()

colors = []

for i in range(3):

(tmp_path / f"p{i}").mkdir()

colors.append(client.post("/api/projects", json={"path": str(tmp_path / f"p{i}")}).json()["color"])

assert colors == [0, 1, 2]

assert client.put("/api/settings", json={"layout_mode": "free"}).json()["layout_mode"] == "free"

"""cloudflared stand-in: prints the URL and the ready line, then idles (or exits with --exit)."""

stub = tmp_path / "cloudflared.py"

stub.write_text(FAKE_CLOUDFLARED)

argv = [sys.executable, str(stub)]

monkeypatch.setattr(share, "command", lambda: argv)

b.post("/api/auth/setup", json={"password": password, "confirm": password})

cli = {"X-Shelldeck-Token": auth.read_cli_token()}

auth.accept_terms(share.TERMS_VERSION)

tunnel = {"host": "abc-def.trycloudflare.com", "cf-connecting-ip": "203.0.113.9", "x-forwarded-for": "203.0.113.9"}

headers = {**gate, "origin": "https://" + tunnel["host"], **({"X-Shelldeck-Client": "ios"} if ios else {})}

r = b.post("/api/auth/login", json={"password": "long enough pass"}, headers=headers)

assert r.status_code == 200

b = browser

cli, tunnel = _share_setup(b)

assert b.get("/", headers=tunnel).status_code == 403 # not shared

state = b.get("/api/share", headers=cli).json()

assert state["sharing"] is False and state["link"] is None and state["cloudflared"] is True

path = _start(b, cli)

link = b.get("/api/share", headers=cli).json()["link"]

assert link["qr_svg"].startswith("<svg") and link["expires_at"] > time.time()

assert link["url"] == f"https://{tunnel['host']}{path}#k={server.e2e.public()}" # the app pins the e2e key from it

assert b.post("/api/share", headers=cli).json()["link"]["path"] == path # already running: unchanged

# the bare tunnel URL and a wrong token get nothing; the link waits for the host

assert b.get("/", headers=tunnel).status_code == 403

assert b.get("/share/wrong", headers=tunnel).status_code == 403

r, gate = _open_link(b, path, tunnel)

assert r.status_code == 200 and "secure" in r.headers["set-cookie"].lower() and "Waiting" in r.text

assert b.get("/", headers=gate).status_code == 403 # pending

status = b.get("/share/status", headers=gate).json()

assert status["state"] == "pending" and re.fullmatch(r"\d{4}", status["code"])

assert b.get("/api/share", headers=cli).json()["pending"][0]["code"] == status["code"] # the host compares it

assert "code" not in b.get("/share/status", headers=tunnel).json() # another browser doesn't get it

assert b.get(path, headers=tunnel).status_code == 403 # the link worked once

assert b.get("/api/share", headers=cli).json()["link"] is None

assert _allow(b, cli).json() == {"state": "ok"}

assert b.get("/share/status", headers=gate).json() == {"state": "ok"}

assert b.get("/", headers=gate).status_code == 200

# the password is still required, and tunnel visitors are remote

assert b.get("/api/projects", headers=gate).json() == {"error": "locked"}

assert b.post("/api/auth/login-link", headers=gate).status_code == 403

authed = _phone_login(b, gate, tunnel)

assert b.get("/api/projects", headers=authed).status_code == 200