painapple-code 1.0.3__tar.gz → 1.0.4__tar.gz

{painapple_code-1.0.3/src/painapple_code.egg-info → painapple_code-1.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: painapple-code
-Version: 1.0.3
+Version: 1.0.4
 Summary: Self-hosted remote UI for Claude Code that journals every turn - background AI summaries become shadow-git commits and a queryable DuckDB history
 Author-email: Michał Booth-Wrotkowski <michal@boothw.com>
 License-Expression: AGPL-3.0-or-later

{painapple_code-1.0.3 → painapple_code-1.0.4}/docs-site/getting-started/install-docker.md

@@ -35,6 +35,9 @@ Docker and Podman are auto-detected (pick one — or a custom binary path — in
 ## Option B — raw `docker run` (one-liner, no clone needed)
 
 ```bash
+# Podman won't create a missing bind-mount source (Docker will) — make it first:
+mkdir -p "$HOME/.painapple-code/.claude"
+
 docker run -d --name painapple-code \
     -p 127.0.0.1:8765:8765 \
     -v "$PWD:/workspace" \
@@ -44,10 +47,27 @@ docker run -d --name painapple-code \
 # Bootstrap URL — the container hides credentials from its own logs, so
 # read the derived API token from its config instead (?tkn= links never
 # carry the password):
-echo "http://localhost:8765/?tkn=$(docker exec painapple-code \
+echo "https://localhost:8765/?tkn=$(docker exec painapple-code \
     awk '/^api_token:/ {print $2}' /home/app/.config/painapple-code/config.yaml)"
 ```
 
+!!! note "Why `https://` here, but `http://` with `painapple --in-docker`"
+
+    The server inside the container always binds `0.0.0.0` — it has to, or
+    the published port would have nothing to forward to. So it cannot tell
+    whether you published on loopback or on the LAN, and `--tls auto`
+    resolves to **on**: you get HTTPS with a self-signed certificate and a
+    one-time browser warning. That is the safe default for a command whose
+    reachability is unknown.
+
+    `painapple --in-docker` knows the publish interface, so it resolves TLS
+    on the host side and turns it off for a loopback-only run.
+
+    You *can* append `--tls off` to the `docker run` command for plain HTTP
+    on a loopback publish — but then remember to remove it if you ever widen
+    `-p 127.0.0.1:…` to another interface, or the token and chat traffic go
+    out unencrypted.
+
 **Image tags:**
 
 | Tag | Meaning |
@@ -84,7 +104,7 @@ To layer your own tooling on top of the base image:
 ./painapple-docker.sh build --dockerfile ~/my-project/Dockerfile
 ```
 
-Open `http://localhost:8765/` in a browser. The first run generates an auth password — the container keeps it out of `docker logs` (they persist), so reveal the bootstrap URL with `painapple password` (pip CLI) or the `docker exec … awk` one-liner above, and open it once; the cookie keeps you logged in. See [First run & login](first-run.md).
+Open `https://localhost:8765/` in a browser (self-signed certificate — accept the one-time warning). The first run generates an auth password — the container keeps it out of `docker logs` (they persist), so reveal the bootstrap URL with `painapple password` (pip CLI) or the `docker exec … awk` one-liner above, and open it once; the cookie keeps you logged in. See [First run & login](first-run.md).
 
 ## Manual Compose / Podman (no wrapper)
 

{painapple_code-1.0.3 → painapple_code-1.0.4}/src/painapple_code/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.0.3'
-__version_tuple__ = version_tuple = (1, 0, 3)
+__version__ = version = '1.0.4'
+__version_tuple__ = version_tuple = (1, 0, 4)
 
-__commit_id__ = commit_id = 'g1be1164'
+__commit_id__ = commit_id = 'g682c211'

{painapple_code-1.0.3 → painapple_code-1.0.4}/src/painapple_code/cli/deploy/container.py

@@ -14,6 +14,7 @@ import threading
 import time
 from pathlib import Path
 
+from painapple_code import __version__
 from painapple_code.cli.netinfo import detect_local_ips
 from painapple_code.cli.ui import (
     BOLD, DIM, GREEN, RESET, die, err, info, ok, print_credentials, say, warn,
@@ -136,6 +137,70 @@ def print_bootstrap_url(cfg, pw, profile=None, raw_tty=False, token=None):
     sys.stdout.flush()
 
 
+def suggest_profile_name(workspace):
+    """A profile name suggestion derived from the workspace dir, or ''.
+
+    Sanitized to profiles.valid_name()'s alphabet so the printed command
+    actually runs, and skipped when the name is already taken (a hint
+    that would reconfigure someone's existing deployment is worse than
+    no hint) or reserved ('default').
+    """
+    import re
+    from painapple_code.cli import profiles
+
+    base = Path(workspace or "").name.lower()
+    # Strip separators from BOTH ends, and again after truncation — a cut
+    # at 32 chars can leave a trailing dash of its own.
+    name = re.sub(r"[^a-z0-9._-]", "-", base).strip("-._")[:32].strip("-._")
+    if not name or not profiles.valid_name(name):
+        return ""
+    return "" if name in profiles.list_profiles() else name
+
+
+# ──── image version ──────────────────────────────────────────────────────
+
+def _release_tuple(version):
+    """(major, minor, patch) from a version string, pre/dev/local suffixes
+    dropped — "1.0.0rc1" → (1, 0, 0). None when it can't be parsed."""
+    if not version:
+        return None
+    parts = []
+    for chunk in version.lstrip("vV").split("+")[0].split(".")[:3]:
+        digits = ""
+        for ch in chunk:
+            if not ch.isdigit():
+                break
+            digits += ch
+        if not digits:
+            break
+        parts.append(int(digits))
+    return tuple(parts) if len(parts) == 3 else None
+
+
+def _is_prerelease(version):
+    core = (version or "").lstrip("vV").split("+")[0]
+    return any(marker in core for marker in ("rc", "a", "b", "dev"))
+
+
+def _image_is_stale(img_version, cli=None):
+    """Is the local image an older build than this CLI?
+
+    Only a CONFIDENT comparison warns — an unparseable or unlabeled
+    version stays quiet rather than crying wolf on every start. Equal
+    releases still count as stale when the image is a pre-release and
+    the CLI is not (an rc image under a released CLI). ``cli`` overrides
+    the running version (tests).
+    """
+    cli_version = cli or __version__
+    img, cli_rel = _release_tuple(img_version), _release_tuple(cli_version)
+    if img is None or cli_rel is None:
+        return False
+    if img < cli_rel:
+        return True
+    return (img == cli_rel and _is_prerelease(img_version)
+            and not _is_prerelease(cli_version))
+
+
 # ──── pull ────────────────────────────────────────────────────────────────
 
 def pull_image(cfg, rt, tag="latest", source=None):
@@ -400,6 +465,13 @@ def build_run_argv(cfg, rt, detach, profile=None, ident=None):
     argv += [cfg.image, "python", "-m", "painapple_code",
              "--host", "0.0.0.0", "--port", "8765",
              "--workspace", "/workspace"]
+    # Parent mode mounts the dir AT /workspace. If it's a git checkout
+    # (forced --no-project, or a hand-edited profile), the container's own
+    # serve auto-detect would see /workspace/.git and flip to single-project
+    # mode — pin it to wrapper. Only appended when needed: older images
+    # don't know the flag and would crash-loop on it.
+    if cfg.workspace_mode == "parent" and (Path(cfg.workspace) / ".git").exists():
+        argv += ["--no-project"]
     if cfg.instance_name:
         argv += ["--instance-name", cfg.instance_name]
     if cfg.accent:
@@ -530,7 +602,7 @@ def run_container(cfg, detach, profile=None):
     # inside the runtime with a message that never mentions painapple
     # ("pasta failed with exit code 1…") — and, being on stderr, it lands
     # out of order among our own lines. Check it ourselves, first.
-    from painapple_code.cli.netinfo import port_holder, port_taken
+    from painapple_code.cli.netinfo import first_free_port, port_holder, port_taken
     reason = port_taken(cfg.listen_host, cfg.port)
     if reason:
         if getattr(reason, "bad_host", False):
@@ -540,7 +612,36 @@ def run_container(cfg, detach, profile=None):
         holder = port_holder(cfg.port)
         err(f"Port {cfg.port} on {cfg.listen_host} is already in use — {reason}"
             + (f" (held by {holder})" if holder else ""))
-        say(f"  {DIM}Pick another port:  {hint('setup', profile)}{RESET}")
+        # Lead with the one-off retry, not the wizard: the user wants THIS
+        # launch to go, and `setup` rewrites global/profile defaults for
+        # every future start. A concrete free port beats "pick another".
+        #
+        # A named profile gets the whole command (self-contained). The
+        # ad-hoc sandbox gets the FLAG to append instead — printing
+        # `painapple --in-docker --port N` would quietly drop the rest of
+        # what the user typed (--project, --workspace, --accent …), and a
+        # copied hint that changes behavior is worse than no hint.
+        free = first_free_port(cfg.listen_host, cfg.port + 1)
+        port_arg = f"--port {free}" if free else "--port N"
+        if profile:
+            say(f"  {DIM}Retry on another port:  "
+                f"{hint('start', profile)} {port_arg}{RESET}")
+            say(f"  {DIM}Or change the saved default:  "
+                f"{hint('setup', profile)}{RESET}")
+        else:
+            say(f"  {DIM}Retry on another port:  add {port_arg} to your "
+                f"command{RESET}")
+            # A named profile is the right PERMANENT answer for a
+            # repeat launch that collides: it gets its own port,
+            # container, volumes and config. Unnamed `setup` would
+            # instead move the GLOBAL default under every future
+            # launch — rarely what someone juggling two instances wants,
+            # so it goes last.
+            suggested = suggest_profile_name(cfg.workspace)
+            say(f"  {DIM}Or save it as its own deployment:  "
+                f"painapple setup {suggested or 'NAME'}{RESET}")
+            say(f"  {DIM}Or change the global default:  "
+                f"{hint('setup', profile)}{RESET}")
         return 1
 
     # Bind-mount dirs must exist so docker doesn't create them as root.
@@ -567,6 +668,20 @@ def run_container(cfg, detach, profile=None):
     say(f"  Config    : {DIM}{cfg.config_volume}{RESET} ({'bind' if cfg.config_is_bind() else 'volume'}) → /home/app/.config/painapple-code")
     say(f"  Listen on : {DIM}{cfg.listen_host}:{cfg.port}{RESET} → container :8765 "
         f"{DIM}(host bind — {listen_scope(cfg)}){RESET}")
+    # Name the image's version, always — the same reason `pull` does it.
+    # `run` uses whatever image is already local and never re-pulls, so a
+    # box that pulled once during the rc series keeps booting that build
+    # forever while the host CLI reports a current version. Unlabeled
+    # (pre-label) images say so rather than printing nothing.
+    img_version = rt.label(cfg.image, "org.opencontainers.image.version")
+    say(f"  Image     : {DIM}{cfg.image}{RESET}"
+        + (f"  {DIM}(version {img_version}){RESET}" if img_version
+           else f"  {DIM}(version unknown — predates the label){RESET}"))
+    if _image_is_stale(img_version):
+        warn(f"The local image is {img_version or 'older than this CLI'} but "
+             f"this CLI is {__version__} — flags and endpoints added since "
+             f"then will be missing inside the container. Refresh it with: "
+             f"{hint('pull', profile)}")
     if cfg.instance_name:
         say(f"  Instance  : {DIM}{cfg.instance_name}{RESET}")
     if cfg.accent:

{painapple_code-1.0.3 → painapple_code-1.0.4}/src/painapple_code/cli/deploy/launch.py

@@ -58,13 +58,36 @@ def _apply_serve_flags(cfg, argv):
     return False
 
 
-def _auto_workspace_mode(cfg):
-    """Zero-config mode pick: a git checkout → 'project', anything else
+def _forced_project_flag(argv):
+    """--project / --no-project from raw argv: True / False / None (auto).
+    Last occurrence wins, matching argparse BooleanOptionalAction."""
+    forced = None
+    for tok in argv:
+        if tok == "--project":
+            forced = True
+        elif tok == "--no-project":
+            forced = False
+    return forced
+
+
+def _auto_workspace_mode(cfg, argv=()):
+    """Mode pick for the mount layer. --project/--no-project force it;
+    otherwise zero-config: a git checkout → 'project', anything else
     → 'parent' — matching "I'm in a repo" vs "I opened a folder of
-    repos" without asking. (.git can be a dir or a worktree file.)"""
+    repos" without asking. (.git can be a dir or a worktree file.)
+    The serve flag itself is NOT forwarded into the container — project
+    mode is realized by the one-level-down mount (container_mount());
+    build_run_argv adds --no-project only where the container's own
+    auto-detect would wrongly flip a parent-mode git mount."""
     ws = Path(cfg.workspace or ".")
-    mode = "project" if (ws / ".git").exists() else "parent"
-    reason = "found .git" if mode == "project" else "no .git"
+    forced = _forced_project_flag(argv)
+    if forced is True:
+        mode, reason = "project", "forced by --project"
+    elif forced is False:
+        mode, reason = "parent", "forced by --no-project"
+    else:
+        mode = "project" if (ws / ".git").exists() else "parent"
+        reason = "found .git" if mode == "project" else "no .git"
     cfg.workspace_mode = mode
     info(f"{ws} → {mode} mode {DIM}({reason}){RESET}")
 
@@ -100,7 +123,7 @@ def adhoc_settings(argv):
     explicit_ws = _apply_serve_flags(cfg, argv)
     if not explicit_ws:
         cfg.workspace = str(Path.cwd())
-    _auto_workspace_mode(cfg)
+    _auto_workspace_mode(cfg, argv)
     return cfg
 
 
@@ -146,9 +169,9 @@ def profile_settings(prof, argv=()):
     explicit_ws = _apply_serve_flags(cfg, list(argv))
     if not cfg.workspace and cfg.workspace_mode != "multi":
         cfg.workspace = str(Path.cwd())
-        _auto_workspace_mode(cfg)
+        _auto_workspace_mode(cfg, argv)
     elif explicit_ws and prof.is_docker is False:
-        _auto_workspace_mode(cfg)
+        _auto_workspace_mode(cfg, argv)
     return cfg
 
 

{painapple_code-1.0.3 → painapple_code-1.0.4}/src/painapple_code/cli/lifecycle_cmd.py

@@ -280,7 +280,7 @@ def _start(target, extra):
     # Bind test, not a scan of our own process table — a port held by
     # ANYTHING (another painapple, a stray dev server) must fail here,
     # loudly, rather than inside a detached child nobody is watching.
-    from painapple_code.cli.netinfo import port_holder, port_taken
+    from painapple_code.cli.netinfo import first_free_port, port_holder, port_taken
     reason = port_taken(host, port)
     if reason:
         if getattr(reason, "bad_host", False):
@@ -289,6 +289,16 @@ def _start(target, extra):
         holder = port_holder(port)
         err(f"Port {port} on {host} is already in use — {reason}"
             + (f" (held by {holder})" if holder else ""))
+        # Same actionable exit as the container path: a concrete free port
+        # to retry on, then the wizard for a permanent change.
+        free = first_free_port(host, port + 1)
+        port_arg = f"--port {free}" if free else "--port N"
+        label = target.get("label") or ""
+        name = label if label and label != "default" else ""
+        say(f"  {DIM}Retry on another port:  "
+            f"painapple start{f' {name}' if name else ''} {port_arg}{RESET}")
+        say(f"  {DIM}Or change the saved default:  "
+            f"painapple setup{f' {name}' if name else ''}{RESET}")
         return 1
 
     return _spawn_and_wait(

{painapple_code-1.0.3 → painapple_code-1.0.4}/src/painapple_code/cli/netinfo.py

@@ -97,6 +97,19 @@ def port_taken(host, port):
     return ""
 
 
+def first_free_port(host, start, span=40):
+    """First bindable port at or above ``start``, or None if the whole
+    span is taken. Used to turn "port busy" into an actionable
+    "--port N" suggestion instead of sending the user to a wizard."""
+    for candidate in range(start, min(start + span, 65536)):
+        reason = port_taken(host, candidate)
+        if getattr(reason, "bad_host", False):
+            return None          # host is the problem — no port helps
+        if not reason:
+            return candidate
+    return None
+
+
 def _listener_pid(port):
     """PID of whatever holds the listening socket on `port`, or None.
     Never raises — every caller is decoration."""

{painapple_code-1.0.3 → painapple_code-1.0.4}/src/painapple_code/cli/setup_cmd.py

@@ -74,8 +74,16 @@ def step_network(cfg, back, n=1):
         warn(f"Server will be reachable on {cfg['host']} — anyone with the "
              "password can connect.")
 
-    port = ui.int_input("Port to bind", default=cfg.get("port") or 8765,
-                        lo=1, hi=65535)
+    # A profile the user has already configured keeps its own port. A NEW
+    # one defaults to the first FREE port at/above 8765 rather than 8765
+    # flat: the common reason to create a second deployment is that
+    # something already holds the default, and offering the taken port
+    # walks straight back into the collision that sent them here.
+    default_port = cfg.get("port")
+    if not default_port:
+        from painapple_code.cli.netinfo import first_free_port
+        default_port = first_free_port(cfg.get("host") or "127.0.0.1", 8765) or 8765
+    port = ui.int_input("Port to bind", default=default_port, lo=1, hi=65535)
     if port is BACK:
         return step_network(cfg, back, n)
     cfg["port"] = port
@@ -568,7 +576,11 @@ def _profile_setup(name):
         docker_only(lambda back: step_storage(cfg, back)),
     ]
 
-    # Warn about port collisions with other profiles (advisory only).
+    # Warn about port collisions (advisory only) — against other
+    # profiles AND against whatever is listening right now. The
+    # profile-only check missed the case that actually bites: the root
+    # deployment (or any unmanaged process) already holding the port,
+    # which is configured nowhere this loop can see.
     def _port_clash():
         for other in profiles.list_profiles():
             if other == name:
@@ -578,6 +590,14 @@ def _profile_setup(name):
                 warn(f"Port {cfg.get('port')} is also configured on profile "
                      f"'{other}' — they can't run at the same time.")
                 return
+        from painapple_code.cli.netinfo import port_holder, port_taken
+        host = cfg.get("host") or "127.0.0.1"
+        reason = port_taken(host, cfg.get("port"))
+        if reason and not getattr(reason, "bad_host", False):
+            holder = port_holder(cfg.get("port"))
+            warn(f"Port {cfg.get('port')} on {host} is in use right now"
+                 + (f" (held by {holder})" if holder else "")
+                 + " — this profile won't start until that frees up.")
 
     try:
         i = 0

{painapple_code-1.0.3 → painapple_code-1.0.4/src/painapple_code.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: painapple-code
-Version: 1.0.3
+Version: 1.0.4
 Summary: Self-hosted remote UI for Claude Code that journals every turn - background AI summaries become shadow-git commits and a queryable DuckDB history
 Author-email: Michał Booth-Wrotkowski <michal@boothw.com>
 License-Expression: AGPL-3.0-or-later

{painapple_code-1.0.3 → painapple_code-1.0.4}/src/painapple_code.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "1.0.3",
+  "tag": "1.0.4",
   "distance": 0,
-  "node": "g1be1164",
+  "node": "g682c211",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-31"