taskops-cli 0.3.1__py3-none-any.whl → 0.3.2__py3-none-any.whl

taskops/_version.py

@@ -1,4 +1,4 @@
 from __future__ import annotations
 
 __title__ = "taskops"
-__version__ = "0.3.1"  # single source of truth; pyproject reads it dynamically
+__version__ = "0.3.2"  # single source of truth; pyproject reads it dynamically

taskops/cli/serving.py

@@ -110,7 +110,7 @@ def ui(here: Path) -> int:
     port = httpd.server_address[1]
     (root / DIR / "ui.json").write_text(json.dumps({"port": port, "token": token}) + "\n")
     window.retire_when_idle(httpd.mounts, httpd)
-    _open(f"http://127.0.0.1:{port}/board/ui/?token={token}")
+    _open(f"http://127.0.0.1:{port}/?token={token}")
     try:
         httpd.serve_forever()
     except KeyboardInterrupt:

taskops/cli/window.py

@@ -104,7 +104,7 @@ def holder(folder: Path, checkout: Path) -> str:
                 f"ctrl-c in its terminal, or wait ~{int(IDLE_SECONDS / 60)} minutes: "
                 "a window with no open tab retires itself"
             )
-        return f"http://127.0.0.1:{port}/board/ui/?token={token}"
+        return f"http://127.0.0.1:{port}/?token={token}"
     raise TaskopsError(
         f"something holds {folder / LOCK} but no window answers on port {port or '?'} — "
         "it may be starting (run this again) or wedged: find it with "

taskops/gitwork/bind.py

@@ -144,7 +144,16 @@ def drain(board: Caller, repo: Path) -> int:
 
 
 def push_card(repo: Path, branch: str) -> bool:
-    """Publish the card's branch so a PR (or the orchestrator) can see it."""
+    """Publish the card's branch so a PR (or the orchestrator) can see it.
+
+    BOTH sides of the refspec, for the reason `remote.push` carries in full: a
+    one-sided `origin <branch>` is resolved through `push.default`, and under
+    `upstream` that is the tracked branch and not this one. Here the tracking is
+    also what `--set-upstream` is about to write, so the wrong destination and
+    the record of it would agree with each other.
+    """
     if not trailer.card_of(branch):
         return False
-    return run.git("push", "--set-upstream", "origin", branch, cwd=repo).ok
+    return run.git(
+        "push", "--set-upstream", "origin", f"{branch}:refs/heads/{branch}", cwd=repo
+    ).ok

taskops/gitwork/remote.py

@@ -142,6 +142,19 @@ def push(repo: Path, *branches: str, cwd: Path | None = None) -> None:
         return
     for name in names:
         try:
-            run.git("push", "origin", name, cwd=where, timeout=PUSH_TIMEOUT)
+            # BOTH sides of the refspec, always. `git push origin <name>` looks
+            # explicit and is not: with no colon, git resolves the destination
+            # through `push.default`, and under `upstream` — a setting a human
+            # may have in ~/.gitconfig for their own reasons — that destination
+            # is the branch's UPSTREAM, not its name. Measured here on
+            # 2026-08-10: milestone branches cut in v1 still tracked
+            # `origin/main`, so this best-effort visibility push was writing
+            # integration branches onto MAIN, in a function that swallows every
+            # error, in a repo whose whole point is that only the human lands
+            # anything on the trunk. `<name>:refs/heads/<name>` cannot be
+            # reinterpreted by any config.
+            run.git(
+                "push", "origin", f"{name}:refs/heads/{name}", cwd=where, timeout=PUSH_TIMEOUT
+            )
         except TaskopsError:  # timeout, or no git at all — never the caller's problem
             return

taskops/http/gitdoor.py

@@ -94,6 +94,7 @@ ABSENT = (
 
 HTML = "text/html"
 TEXT = "text/plain"
+MARKDOWN = "text/markdown"
 
 
 def answer(repo: Path | None, tail: str, query: str) -> dict[str, Any]:
@@ -135,9 +136,8 @@ def _file(repo: Path, rev: str, wanted: str) -> dict[str, Any]:
     reading a report is the UI reading a patch, and a second vocabulary would be
     a second renderer. `content_type` is a FIELD, never this response's header —
     every door answers `application/json`, so no path can make THIS origin, the
-    one the token lives in, serve HTML; the reader sandboxes it. `text/html`
-    only for a literal `.html`, because a type this door does not know must
-    degrade to something no renderer will execute."""
+    one the token lives in, serve HTML; the reader sandboxes it. The three types
+    `_kind` answers are argued there."""
     path = reports.under(wanted)
     if not path:
         raise BadRequest(NOT_A_REPORT.format(path=wanted or "a missing ?path="))
@@ -153,7 +153,7 @@ def _file(repo: Path, rev: str, wanted: str) -> dict[str, Any]:
     return {
         "path": path,
         "rev": sha,
-        "content_type": HTML if path.endswith(".html") else TEXT,
+        "content_type": _kind(path),
         "text": text,
         "truncated": cut,
         "cap": patch.CAP,
@@ -186,3 +186,13 @@ def _param(query: str, key: str) -> str:
         if name == key:
             return unquote(value.replace("+", " "))
     return ""
+
+
+def _kind(path: str) -> str:
+    """The three answers, and the default keeps itself safe: an unrecognised
+    type falls to `text/plain`, which every reader draws as characters. Decided
+    HERE and never in the browser — `ReportFrame` reads what the door SAYS a
+    file is, never the extension it can see, so the two cannot drift apart."""
+    if path.endswith(".html"):
+        return HTML
+    return MARKDOWN if path.endswith(".md") else TEXT

taskops/http/handler.py

@@ -70,6 +70,8 @@ class Handler(BaseHTTPRequestHandler):
             self._git(board, tail[4:])
         elif tail.startswith("ui"):
             self._static(tail[2:])
+        elif (page := static.at_root(self.mounts.ui, self.path)) is not None:
+            self._send(200, *page)  # a WINDOW serves its page at the ROOT
         else:
             self._fail(404, BadRequest(f"nothing at {self.path}"))
 

taskops/http/static.py

@@ -84,6 +84,36 @@ def payload(root: Path, rest: str) -> tuple[bytes, str] | None:
     return (path.read_bytes(), content_type(path)) if path else None
 
 
+def at_root(root: Path | None, path: str) -> tuple[bytes, str] | None:
+    """The bundle served at the ROOT of a window — `/`, `/app.js`, `/style.css`.
+
+    `taskops ui` used to hand out `/board/ui/?token=…`, and that path is an
+    implementation detail leaking into the one URL a human types: `board` is
+    just the name a window mounts its single board under, and `/ui/` was the
+    door on a HOST that no longer serves a page at all. A window is a window;
+    its address is its port.
+
+    Deliberately NOT `resolve`: that one falls back to the index for any
+    unknown tail, which is right for a door mounted under `/<board>/ui/` and
+    wrong at the root, where it would swallow every mistyped API path and
+    answer a mistake with a page. Only real files, plus `/` for the index — so
+    `/nope` is still the honest 404 the API gives.
+
+    `root is None` IS the host switch and the only one there is: `Mounts` sets
+    `ui` from the same `repo is not None` that /git and /healthz's identity
+    read, so a board host cannot start serving a dashboard by any route,
+    including this one — there is no second condition to keep in step.
+    """
+    if root is None or not root.is_dir():
+        return None
+    rest = path.partition("?")[0].strip("/")
+    base = root.resolve()
+    target = (root / INDEX) if not rest else (root / rest).resolve()
+    if base != target and base not in target.parents:
+        return None  # `..%2f..` and symlinks have already collapsed
+    return (target.read_bytes(), content_type(target)) if target.is_file() else None
+
+
 def answer(root: Path | None, rest: str) -> tuple[int, bytes, str]:
     """The WHOLE /ui door: (status, body, content-type). `root is None` means
     this process is a board host — see the module docstring for why that is a

taskops/http/upstream.py

@@ -1,7 +1,7 @@
 """The remote board a LOCAL window is a window onto — the one thing that differs.
 
 `taskops ui` always serves the dashboard from the checkout it stands in. The
-routes are the same in both modes (`/board/ui/`, `/board/rpc`, `/board/git/…`),
+routes are the same in both modes (`/` for the page, `/board/rpc`, `/board/git/…`),
 so the committed bundle never learns which kind of board it is talking to. The
 whole difference is who answers `/rpc`: