worklog-for-claude-code 0.3.1__tar.gz → 0.3.2__tar.gz

{worklog_for_claude_code-0.3.1/worklog_for_claude_code.egg-info → worklog_for_claude_code-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: worklog-for-claude-code
-Version: 0.3.1
+Version: 0.3.2
 Summary: See what you did with Claude Code each day and how many tokens it used: an automatic daily work log across accounts and devices, private by default
 Author: Urvin
 License-Expression: MIT
@@ -113,7 +113,11 @@ A checklist then shows anything still missing, with the exact command for your c
 
 **Several accounts or computers?** Settings walks you through it. For several computers, see [Full setup](https://github.com/us-urvin/worklog-for-claude-code/blob/main/docs/GUIDE.md#full-setup).
 
-**How do I update?** Click **Update now** when the dashboard says a new version is out, or run `pipx upgrade worklog-for-claude-code`.
+**Using several GitHub accounts?** GitHub knows you by your SSH key. In Settings → Private data repo, click **Test connection** to see which account signs in, and open *Several GitHub accounts on this computer?* for the steps. [More →](https://github.com/us-urvin/worklog-for-claude-code/blob/main/docs/GUIDE.md#full-setup)
+
+**Uploads to my data repo fail?** Click **Test connection** in Settings: it says what's wrong in plain words. See [Troubleshooting](https://github.com/us-urvin/worklog-for-claude-code/blob/main/docs/TROUBLESHOOTING.md#uploads-fail-or-the-wrong-github-account-is-used).
+
+**How do I update?** Click **Update now** when the dashboard says a new version is out, or run `pipx upgrade --pip-args=--no-cache-dir worklog-for-claude-code`.
 
 **Something isn't working?** Run `claude-worklog doctor`, or see [Troubleshooting](https://github.com/us-urvin/worklog-for-claude-code/blob/main/docs/TROUBLESHOOTING.md).
 

{worklog_for_claude_code-0.3.1 → worklog_for_claude_code-0.3.2}/README.md

@@ -74,7 +74,11 @@ A checklist then shows anything still missing, with the exact command for your c
 
 **Several accounts or computers?** Settings walks you through it. For several computers, see [Full setup](https://github.com/us-urvin/worklog-for-claude-code/blob/main/docs/GUIDE.md#full-setup).
 
-**How do I update?** Click **Update now** when the dashboard says a new version is out, or run `pipx upgrade worklog-for-claude-code`.
+**Using several GitHub accounts?** GitHub knows you by your SSH key. In Settings → Private data repo, click **Test connection** to see which account signs in, and open *Several GitHub accounts on this computer?* for the steps. [More →](https://github.com/us-urvin/worklog-for-claude-code/blob/main/docs/GUIDE.md#full-setup)
+
+**Uploads to my data repo fail?** Click **Test connection** in Settings: it says what's wrong in plain words. See [Troubleshooting](https://github.com/us-urvin/worklog-for-claude-code/blob/main/docs/TROUBLESHOOTING.md#uploads-fail-or-the-wrong-github-account-is-used).
+
+**How do I update?** Click **Update now** when the dashboard says a new version is out, or run `pipx upgrade --pip-args=--no-cache-dir worklog-for-claude-code`.
 
 **Something isn't working?** Run `claude-worklog doctor`, or see [Troubleshooting](https://github.com/us-urvin/worklog-for-claude-code/blob/main/docs/TROUBLESHOOTING.md).
 

{worklog_for_claude_code-0.3.1 → worklog_for_claude_code-0.3.2}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 # Distribution name on PyPI. The command stays `claude-worklog` and the package stays `worklog`.
 name = "worklog-for-claude-code"
-version = "0.3.1"
+version = "0.3.2"
 description = "See what you did with Claude Code each day and how many tokens it used: an automatic daily work log across accounts and devices, private by default"
 readme = "README.md"
 requires-python = ">=3.10"

worklog_for_claude_code-0.3.2/tests/test_syncstatus.py

@@ -0,0 +1,208 @@
+"""Settings → Private data repo: connected or not, which repo, private or public, and whether syncing works."""
+import io
+import json
+import subprocess
+from urllib.error import HTTPError
+
+import pytest
+from test_accounts import make_cfg
+
+from worklog import syncstatus, web
+from worklog.store import GitStore
+
+
+def git(repo, *args):
+    subprocess.run(["git", "-C", str(repo), *args], check=True, capture_output=True)
+
+
+def section(cfg):
+    return web.data_repo_section(web.App(1), cfg)
+
+
+@pytest.fixture
+def no_network(monkeypatch):
+    def fail(*a, **k):
+        raise AssertionError("no network expected here")
+    monkeypatch.setattr(syncstatus, "urlopen", fail)
+
+
+def test_not_a_git_folder_says_not_set_up(home, repo, no_network):
+    cfg = make_cfg(home, repo)
+    cfg.store_repo = home / "nowhere"
+    html = section(cfg)
+    assert "Not set up" in html and "git init" in html
+
+
+def test_local_only_explains_how_to_connect(home, repo, no_network):
+    html = section(make_cfg(home, repo))
+    assert "Local only" in html and "Not connected" in html and "remote add origin" in html and "Copy" in html
+
+
+def test_connected_shows_which_repo_and_never_the_credentials(home, repo, monkeypatch):
+    git(repo, "remote", "add", "origin", "https://me:ghp_SECRET123@github.com/me/claude-worklog-data.git")
+    monkeypatch.setattr(syncstatus, "urlopen", lambda *a, **k: (_ for _ in ()).throw(
+        HTTPError("u", 404, "Not Found", {}, io.BytesIO(b""))))
+    syncstatus.visibility("github.com", "me/claude-worklog-data")  # what the background check does
+    html = section(make_cfg(home, repo))
+    assert "Connected" in html and "github.com/me/claude-worklog-data" in html
+    assert 'href="https://github.com/me/claude-worklog-data"' in html
+    assert "SECRET" not in html and "ghp_" not in html and "me:ghp" not in html
+    assert "🔒 Private" in html and "Not uploaded yet" in html
+
+
+def test_public_repo_is_flagged_everywhere(home, repo, monkeypatch):
+    git(repo, "remote", "add", "origin", "git@github.com:me/claude-worklog-data.git")
+    monkeypatch.setattr(syncstatus, "urlopen", lambda *a, **k: io.BytesIO(json.dumps({"private": False}).encode()))
+    assert syncstatus.visibility("github.com", "me/claude-worklog-data") == "public"
+    cfg = make_cfg(home, repo)
+    assert "PUBLIC" in section(cfg) and "Change visibility" in section(cfg)
+    assert "is public" in web._public_repo_warning(cfg)  # the warning on every page
+
+
+def test_visibility_is_cached_and_only_asked_for_github(home, monkeypatch):
+    calls = []
+
+    def fake(req, timeout):
+        calls.append(req.full_url)
+        return io.BytesIO(b'{"private": true}')
+    monkeypatch.setattr(syncstatus, "urlopen", fake)
+    assert syncstatus.visibility("github.com", "me/r") == "private"
+    assert syncstatus.visibility("github.com", "me/r") == "private" and len(calls) == 1  # cached
+    assert syncstatus.visibility("gitlab.com", "me/r") == "unknown" and len(calls) == 1  # never asks other hosts
+    assert calls == ["https://api.github.com/repos/me/r"]
+    monkeypatch.setattr(syncstatus, "urlopen", lambda *a, **k: (_ for _ in ()).throw(OSError("offline")))
+    assert syncstatus.visibility("github.com", "me/other") == "unknown"
+
+
+def test_store_records_uploads_and_failures(home, repo, tmp_path, no_network):
+    bare = tmp_path / "remote.git"
+    subprocess.run(["git", "init", "-q", "--bare", str(bare)], check=True)
+    git(repo, "remote", "add", "origin", str(bare))
+    store = GitStore(repo)
+    store.write_json("records/2026-11-01/dev/personal/a.json", {"a": 1})
+    store.commit_and_push("test")
+    assert syncstatus.last("push")["ok"] is True
+    git(repo, "remote", "set-url", "origin", str(tmp_path / "missing.git"))
+    store.write_json("records/2026-11-01/dev/personal/b.json", {"b": 1})
+    store.commit_and_push("test 2")
+    failed = syncstatus.last("push")
+    assert failed["ok"] is False and failed["error"]
+
+
+def test_failed_upload_and_waiting_changes_are_shown(home, repo, no_network):
+    git(repo, "remote", "add", "origin", "git@gitlab.com:me/data.git")
+    GitStore(repo).write_json("records/2026-11-01/dev/personal/a.json", {"a": 1})
+    git(repo, "add", "-A")
+    subprocess.run(["git", "-C", str(repo), "-c", "user.name=t", "-c", "user.email=t@t", "commit", "-qm", "x"],
+                   check=True)
+    syncstatus.record("push", False, "fatal: Could not read from remote repository.")
+    html = section(make_cfg(home, repo))
+    assert "Last upload failed" in html and "Could not read from remote repository" in html
+    assert "1 change waiting to upload" in html
+    assert "Privacy not checked" in html  # not GitHub: no request is made
+    syncstatus.record("push", True)
+    assert "Synced" in section(make_cfg(home, repo))
+
+
+def test_test_connection_works_and_explains_failures(home, repo, tmp_path):
+    bare = tmp_path / "remote.git"
+    subprocess.run(["git", "init", "-q", "--bare", str(bare)], check=True)
+    git(repo, "remote", "add", "origin", str(bare))
+    cfg = make_cfg(home, repo)
+    ok, msg = syncstatus.test_connection(cfg)
+    assert ok and "Connection works" in msg
+    git(repo, "remote", "set-url", "origin", str(tmp_path / "missing.git"))
+    ok, msg = syncstatus.test_connection(cfg)
+    assert not ok and msg.startswith("Can't reach your data repo")
+
+
+def test_sync_works_without_a_git_identity_on_this_computer(home, repo, tmp_path, no_network):
+    """A pull that replays local commits needs a committer name; this computer has none set."""
+    bare = tmp_path / "remote.git"
+    subprocess.run(["git", "init", "-q", "--bare", str(bare)], check=True)
+    git(repo, "remote", "add", "origin", str(bare))
+    git(repo, "config", "user.useConfigOnly", "true")  # like a computer without `git config --global user.email`
+    a = GitStore(repo)
+    a.write_json("records/2026-11-01/a/personal/1.json", {"n": 1})
+    a.commit_and_push("first")
+    other = tmp_path / "other"
+    subprocess.run(["git", "clone", "-q", str(bare), str(other)], check=True)
+    b = GitStore(other)
+    b.write_json("records/2026-11-01/b/personal/2.json", {"n": 2})
+    b.commit_and_push("from the other computer")
+    git(repo, "remote", "set-url", "origin", str(tmp_path / "offline.git"))  # local commits pile up while offline
+    a.write_json("records/2026-11-01/a/personal/3.json", {"n": 3})
+    a.commit_and_push("offline")
+    git(repo, "remote", "set-url", "origin", str(bare))
+    a.pull()
+    assert syncstatus.last("pull")["ok"] is True, syncstatus.last("pull")
+    assert (repo / "records/2026-11-01/b/personal/2.json").exists()
+    a.commit_and_push("nothing new")  # nothing staged, but the waiting commit still goes up
+    assert syncstatus.status(make_cfg(home, repo))["waiting"] == 0
+
+
+def _fake_ssh(monkeypatch, *, who="us-urvin", ls_remote=(0, "", "")):
+    """ssh -G answers from a ~/.ssh/config alias; ssh -T says who the key is; git ls-remote as given."""
+    real_run, real_git = syncstatus.subprocess.run, syncstatus._git
+    syncstatus._ssh_cache.clear()
+    monkeypatch.setattr(syncstatus.shutil, "which", lambda n: "/usr/bin/" + n)
+
+    def run(cmd, *a, **k):
+        if cmd[0] == "ssh" and "-G" in cmd:
+            out = "user git\nhostname github.com\nport 22\nidentityfile ~/.ssh/id_work\n"
+            return subprocess.CompletedProcess(cmd, 0, out, "")
+        if cmd[0] == "ssh" and "-T" in cmd:
+            return subprocess.CompletedProcess(cmd, 1, "", f"Hi {who}! You've successfully authenticated, but GitHub "
+                                                            "does not provide shell access.")
+        return real_run(cmd, *a, **k)
+    monkeypatch.setattr(syncstatus.subprocess, "run", run)
+    monkeypatch.setattr(syncstatus, "_git", lambda repo, *args, **k: ls_remote if args[0] == "ls-remote"
+                        else real_git(repo, *args, **k))
+
+
+def test_ssh_nickname_links_to_the_real_host_and_names_the_key(home, repo, monkeypatch):
+    git(repo, "remote", "add", "origin", "git@worklog-git:us-urvin/claude-worklog-data.git")
+    _fake_ssh(monkeypatch)
+    asked = []
+    monkeypatch.setattr(syncstatus, "urlopen", lambda req, timeout: asked.append(req.full_url) or (_ for _ in ()).throw(
+        HTTPError("u", 404, "Not Found", {}, io.BytesIO(b""))))
+    cfg = make_cfg(home, repo)
+    r = syncstatus.remote(cfg)
+    assert r["host"] == "github.com" and r["alias"] == "worklog-git" and r["key"] == "~/.ssh/id_work"
+    assert syncstatus.visibility(r["host"], r["slug"]) == "private"  # the privacy check works through the nickname
+    html = section(cfg)
+    assert 'href="https://github.com/us-urvin/claude-worklog-data"' in html and "https://worklog-git" not in html
+    assert "worklog-git" in html and "id_work" in html and "Test connection</b> to see which GitHub account" in html
+
+
+def test_test_connection_says_which_account_signs_in(home, repo, monkeypatch):
+    git(repo, "remote", "add", "origin", "git@worklog-git:us-urvin/claude-worklog-data.git")
+    _fake_ssh(monkeypatch)
+    cfg = make_cfg(home, repo)
+    ok, msg = syncstatus.test_connection(cfg)
+    assert ok and "signs in to GitHub as us-urvin" in msg
+    assert "Signs in as us-urvin" in section(cfg)
+
+
+def test_wrong_account_is_explained(home, repo, monkeypatch):
+    git(repo, "remote", "add", "origin", "git@gh-office:us-urvin/claude-worklog-data.git")
+    err = "ERROR: Repository not found.\nfatal: Could not read from remote repository."
+    _fake_ssh(monkeypatch, who="office-u", ls_remote=(128, "", err))
+    ok, msg = syncstatus.test_connection(make_cfg(home, repo))
+    assert not ok and "knows this computer's key as office-u" in msg
+    assert "no access to us-urvin/claude-worklog-data" in msg
+
+
+def test_https_and_local_remotes_are_not_treated_as_ssh(home, repo):
+    git(repo, "remote", "add", "origin", "https://us-urvin@github.com/us-urvin/data.git")
+    r = syncstatus.remote(make_cfg(home, repo))
+    assert r["via"] == "https" and r["user"] == "us-urvin" and r["host"] == "github.com"
+    assert syncstatus._ssh_parts("C:/repos/data.git") is None and syncstatus._ssh_parts("/srv/data.git") is None
+    assert syncstatus._ssh_parts("ssh://git@work-gh:22/me/r.git") == ("git", "work-gh")
+
+
+def test_errors_show_the_line_that_matters():
+    err = ("ssh: connect to host github.com port 22: Connection timed out\nfatal: Could not read from remote "
+           "repository.\n\nPlease make sure you have the correct access rights\nand the repository exists.\n")
+    assert syncstatus._main_line(err).startswith("ssh: connect to host github.com port 22")
+    assert syncstatus._main_line("") == "no answer"

worklog_for_claude_code-0.3.2/tests/test_updates.py

@@ -0,0 +1,211 @@
+"""Update notice and one-click update. PyPI, pip and the restart are faked here."""
+import io
+import json
+import time
+
+import pytest
+from test_accounts import make_cfg
+
+from worklog import __version__, updates, web
+
+
+@pytest.fixture
+def ustate(home, monkeypatch):
+    monkeypatch.setattr(updates, "STATE_DIR", home / ".local/state/claude-worklog")
+    monkeypatch.delenv("CLAUDE_WORKLOG_DEMO", raising=False)
+    return home
+
+
+def test_versions_compare_like_people_expect():
+    assert updates.is_newer("0.3.1", "0.3.0") and updates.is_newer("0.10.0", "0.9.9")
+    assert not updates.is_newer("0.3.0", "0.3.0") and not updates.is_newer("0.2.9", "0.3.0")
+    assert updates.parse("0.4.0rc1") < updates.parse("0.4.0")
+
+
+def test_check_asks_pypi_at_most_once_a_day(ustate, monkeypatch):
+    calls = []
+
+    def fake_urlopen(req, timeout):
+        calls.append(req.full_url)
+        return io.BytesIO(json.dumps({"info": {"version": "9.9.9"}}).encode())
+    monkeypatch.setattr(updates, "urlopen", fake_urlopen)
+    now = time.time()
+    assert updates.check(now=now) == "9.9.9"
+    assert updates.check(now=now + 3600) == "9.9.9" and len(calls) == 1  # cached
+    updates.check(now=now + 25 * 3600)
+    assert len(calls) == 2 and calls[0] == "https://pypi.org/pypi/worklog-for-claude-code/json"
+    assert updates.available() == "9.9.9"
+
+
+def test_offline_or_odd_answers_are_ignored(ustate, monkeypatch):
+    def offline(req, timeout):
+        raise OSError("no network")
+    monkeypatch.setattr(updates, "urlopen", offline)
+    assert updates.check(force=True) is None and updates.available() is None
+    monkeypatch.setattr(updates, "urlopen", lambda req, timeout: io.BytesIO(b'{"info": {"version": "<script>"}}'))
+    assert updates.check(force=True) is None
+
+
+def test_upgrade_command_matches_how_it_was_installed(monkeypatch):
+    monkeypatch.setattr(updates.shutil, "which", lambda n: "/usr/bin/pipx")
+    assert updates.upgrade_command("pipx") == ["/usr/bin/pipx", "upgrade", "--pip-args=--no-cache-dir",
+                                               "worklog-for-claude-code"]
+    assert updates.upgrade_command("venv")[-4:] == ["install", "--upgrade", "--no-cache-dir", "worklog-for-claude-code"]
+    assert "--no-cache-dir" in updates.manual_command("pipx")  # a stale pip cache can't hide the new version
+    assert updates.upgrade_command("dev") is None and updates.upgrade_command("system") is None
+    assert updates.manual_command("system").startswith("python3 -m pip install --user --upgrade")
+
+
+def _state(ustate, latest):
+    p = ustate / ".local/state/claude-worklog/update.json"
+    p.parent.mkdir(parents=True, exist_ok=True)
+    p.write_text(json.dumps({"checked_at": time.time(), "latest": latest}))
+
+
+def test_notice_shows_button_or_command_and_can_be_dismissed(ustate, repo, monkeypatch):
+    cfg = make_cfg(ustate, repo)
+    app = web.App(1)
+    _state(ustate, "9.9.9")
+    monkeypatch.setattr(updates, "install_kind", lambda: "pipx")
+    html = web._update_html(app, cfg)
+    assert "Worklog 9.9.9 is out" in html and f"you have {__version__}" in html and 'action="/update"' in html
+    monkeypatch.setattr(updates, "install_kind", lambda: "system")
+    html = web._update_html(app, cfg)
+    assert 'action="/update"' not in html and "pip install --user --upgrade" in html  # copy the command instead
+    updates.dismiss("9.9.9")
+    assert web._update_html(app, cfg) == ""
+    _state(ustate, __version__)
+    assert web._update_html(app, cfg) == ""  # nothing newer
+    cfg.check_updates = False
+    _state(ustate, "10.0.0")
+    assert web._update_html(app, cfg) == ""  # switched off in Settings
+
+
+def test_update_now_upgrades_then_restarts(ustate, repo, monkeypatch):
+    make_cfg(ustate, repo)
+    monkeypatch.setattr(updates, "install_kind", lambda: "pipx")
+    monkeypatch.setattr(updates, "upgrade", lambda: (True, "Updated."))
+    monkeypatch.setattr(updates, "installed_version", lambda: "9.9.9")
+    restarted = []
+    app = web.App(1)
+    monkeypatch.setattr(app, "restart", lambda: restarted.append(True))
+    monkeypatch.setattr(web.threading, "Timer", lambda delay, fn: type("T", (), {"start": lambda s: fn()})())
+    loc, err, _ = app._update({})
+    assert err is None and loc == "/?ok=job"
+    for _ in range(100):
+        if not app.jobs.snapshot()["running"]:
+            break
+        time.sleep(0.02)
+    assert app.jobs.snapshot()["message"] == "Updated to 9.9.9. Restarting…" and restarted == [True]
+
+
+def _pypi(version, uploaded):
+    files = [{"upload_time_iso_8601": uploaded}] if uploaded else []
+    body = json.dumps({"info": {"version": version}, "releases": {version: files}, "urls": files}).encode()
+    return lambda req, timeout: io.BytesIO(body)
+
+
+def test_a_release_is_announced_only_once_pypi_has_settled(ustate, monkeypatch):
+    from datetime import datetime, timezone
+    t0 = datetime(2026, 11, 2, 12, 0, tzinfo=timezone.utc).timestamp()
+    monkeypatch.setattr(updates, "urlopen", _pypi("9.9.9", "2026-11-02T12:00:00.000000Z"))
+    assert updates.check(force=True, now=t0 + 60) is None  # just published: pip may not see it yet
+    assert updates.check(now=t0 + 600) is None  # not re-checked every request...
+    assert updates.check(now=t0 + 60 + updates.RETRY) == "9.9.9"  # ...but an hour later, not a day
+    monkeypatch.setattr(updates, "urlopen", _pypi("10.0.0", None))
+    assert updates.fetch_latest() is None  # listed but no files uploaded yet
+
+
+def test_update_now_explains_when_pypi_is_still_catching_up(ustate, repo, monkeypatch):
+    make_cfg(ustate, repo)
+    _state(ustate, "9.9.9")
+    monkeypatch.setattr(updates, "install_kind", lambda: "pipx")
+    monkeypatch.setattr(updates, "upgrade", lambda: (True, "Updated."))
+    monkeypatch.setattr(updates, "installed_version", lambda: __version__)  # pip found nothing newer
+    app = web.App(1)
+    app._update({})
+    for _ in range(100):
+        if not app.jobs.snapshot()["running"]:
+            break
+        time.sleep(0.02)
+    snap = app.jobs.snapshot()
+    assert "still publishing Worklog 9.9.9" in snap["message"] and "Try again in a few minutes" in snap["message"]
+
+
+def test_failed_update_says_what_to_do(ustate, repo, monkeypatch):
+    monkeypatch.setattr(updates, "install_kind", lambda: "venv")
+    monkeypatch.setattr(updates.subprocess, "run",
+                        lambda *a, **k: updates.subprocess.CompletedProcess(a, 1, "", "error: externally-managed"))
+    ok, msg = updates.upgrade()
+    assert not ok and "externally-managed" in msg and "Try by hand" in msg
+
+
+def test_updated_message_is_shown_once_and_only_by_the_new_version(ustate):
+    updates.note_updated("9.9.9")
+    assert updates.pop_updated("0.3.0") is None  # the old process, just before it restarts
+    assert updates.pop_updated("9.9.9") == "9.9.9"  # the new one
+    assert updates.pop_updated("9.9.9") is None  # only once
+
+
+def _job(message, ok=True, age=0.0):
+    return {"running": None, "finished": "11:21", "finished_at": time.time() - age, "message": message, "ok": ok}
+
+
+def test_job_results_go_away_by_themselves_and_can_be_closed():
+    page = web.layout("t", "", "day", "n", _job("Updated 178 session record(s)"), csrf="tok")
+    assert "Updated 178 session record(s)" in page and 'action="/jobs/dismiss"' in page
+    assert "Updated 178" not in web.layout("t", "", "day", "n", _job("Updated 178 session record(s)", age=121))
+    failed = _job("Syncing failed: offline", ok=False, age=300)
+    assert "Syncing failed" in web.layout("t", "", "day", "n", failed)  # errors stay longer
+    assert "Syncing failed" not in web.layout("t", "", "day", "n", _job("Syncing failed", ok=False, age=901))
+    restarting = _job("Updated to 9.9.9. Restarting…", age=600)
+    assert 'id="restarting"' in web.layout("t", "", "day", "n", restarting)  # never hidden while restarting
+
+
+def test_dismiss_clears_the_last_result(ustate, repo, monkeypatch):
+    cfg = make_cfg(ustate, repo)
+    monkeypatch.setattr(web, "_try_config", lambda: cfg)
+    app = web.App(1)
+    app.jobs.start("Syncing", lambda: "Synced: 3 records")
+    for _ in range(100):
+        if not app.jobs.snapshot()["running"]:
+            break
+        time.sleep(0.02)
+    assert app.jobs.snapshot()["message"] == "Synced: 3 records"
+    app.post("/jobs/dismiss", {})
+    assert app.jobs.snapshot()["message"] == ""
+
+
+def test_version_on_disk_reads_the_installed_files():
+    assert updates.version_on_disk() == __version__
+
+
+def test_restart_banner_after_a_terminal_upgrade(ustate, repo, monkeypatch):
+    cfg = make_cfg(ustate, repo)
+    monkeypatch.setattr(web, "_try_config", lambda: cfg)
+    app = web.App(1)
+    assert web._restart_html(app) == ""  # same version on disk: nothing to do
+    monkeypatch.setattr(updates, "version_on_disk", lambda: "9.9.9")
+    html = web._restart_html(app)
+    assert "Worklog 9.9.9 is installed" in html and f"still runs {__version__}" in html and 'action="/restart"' in html
+    restarted = []
+    monkeypatch.setattr(app, "restart", lambda: restarted.append(True))
+    monkeypatch.setattr(web.threading, "Timer", lambda delay, fn: type("T", (), {"start": lambda s: fn()})())
+    loc, err, _ = app.post("/restart", {})
+    assert err is None and loc == "/?ok=job"
+    for _ in range(100):
+        if not app.jobs.snapshot()["running"]:
+            break
+        time.sleep(0.02)
+    assert app.jobs.snapshot()["message"] == "Updated to 9.9.9. Restarting…" and restarted == [True]
+
+
+def test_script_sent_forms_get_answers_in_place(ustate, repo):
+    app = web.App(1)
+    assert web._fetch_answer(app, "/settings/watch", None, "Bad value") == {"ok": False, "error": "Bad value"}
+    assert web._fetch_answer(app, "/settings/watch", "/settings?ok=saved", None) == {
+        "ok": True, "message": web.OK_MESSAGES["saved"]}
+    assert web._fetch_answer(app, "/sync/test", "/settings?ok=job#data-repo", None)["job"]  # follow the job
+    app.jobs.start("Syncing", lambda: time.sleep(0.3) or "done")
+    busy = web._fetch_answer(app, "/sync/test", "/settings#data-repo", None)  # couldn't start: something else runs
+    assert busy["ok"] is False and "Syncing" in busy["error"]

{worklog_for_claude_code-0.3.1 → worklog_for_claude_code-0.3.2}/worklog/__init__.py

@@ -1,3 +1,3 @@
 """claude-worklog: daily work log + token report for Claude Code."""
 
-__version__ = "0.3.1"
+__version__ = "0.3.2"

{worklog_for_claude_code-0.3.1 → worklog_for_claude_code-0.3.2}/worklog/store.py

@@ -57,11 +57,22 @@ class GitStore:
     def _has_remote(self) -> bool:
         return bool(self._git("remote", check=False).stdout.strip())
 
+    def _unpushed(self) -> bool:
+        """Commits that an earlier run couldn't upload (offline, or a failed pull) are still waiting."""
+        if not self._has_remote():
+            return False
+        r = self._git("rev-list", "--count", "@{u}..HEAD", check=False)
+        if r.returncode != 0:  # never pushed: anything committed is waiting
+            r = self._git("rev-list", "--count", "HEAD", check=False)
+        return r.returncode == 0 and r.stdout.strip() not in ("", "0")
+
     def pull(self) -> None:
         if not self._has_remote():
             return
         try:
-            self._git("pull", "--rebase", "--autostash", timeout=90)
+            # Replaying local commits on top of the remote ones writes new commits, so git needs a name
+            # here too: without it a computer with no `git config --global user.email` can never sync.
+            self._git(*_IDENTITY, "pull", "--rebase", "--autostash", timeout=90)
             syncstatus.record("pull", True)
         except (subprocess.CalledProcessError, subprocess.TimeoutExpired) as exc:
             # Offline, empty repo, or first run: work locally, sync next time.
@@ -80,9 +91,10 @@ class GitStore:
             attrs.write_text("records/** text eol=lf\nreports/** text eol=lf\n", encoding="utf-8", newline="\n")
             dirs.append(".gitattributes")
         self._git("add", "-A", "--", *dirs)
-        if self._git("diff", "--cached", "--quiet", check=False).returncode == 0:
-            return  # nothing staged
-        self._git(*_IDENTITY, "commit", "-q", "-m", message)
+        if self._git("diff", "--cached", "--quiet", check=False).returncode != 0:
+            self._git(*_IDENTITY, "commit", "-q", "-m", message)
+        elif not self._unpushed():
+            return  # nothing new, and nothing left over from an earlier failed upload
         if not self._has_remote():
             log.info("committed locally (no remote configured)")
             return