flowjet 2.0.4__tar.gz → 2.0.5__tar.gz

{flowjet-2.0.4 → flowjet-2.0.5}/CHANGELOG.md

@@ -10,12 +10,38 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-## [2.0.4] — 2026-09-19
+## [2.0.5] — 2026-09-20
 
 ### Changed
 
-- Bumped `soothe` lower bound to `1.0.13` (was `1.0.12`). soothe-nano stays
-  pinned at `>=1.2.28,<1.3.0`.
+- **Config moved off `~/.soothe` — `FLOWJET_HOME` is now the authority.**
+  The config file resolves to `$FLOWJET_HOME/config/nano.yml` (default
+  `~/.flowjet/config/nano.yml`) instead of `$SOOTHE_HOME/config/nano.yml`, so an
+  exported `SOOTHE_HOME` can no longer drag flowjet back onto `~/.soothe`.
+  `SOOTHE_HOME` itself is left untouched: CLI data (thread pins, locks,
+  completion history), logs, agents, plugins and the sqlite databases still live
+  there. Upgrades keep working — an existing `~/.soothe/config/nano.yml` (plus a
+  sibling `soothe.yml`) is copied into `$FLOWJET_HOME/config/` **once**, on first
+  run, and the originals are left in place, so the move is reversible.
+- **`fj setup` no longer aborts when the LLM endpoint is unreachable.** A failed
+  or empty `/models` probe (connection refused, HTTP error, unresolved
+  `${ENV_VAR}`) now prints a `warning:` and falls through to manual model entry
+  — offering the models already saved for the selected provider, or accepting a
+  typed model id. The provider and router profile are still written, so a config
+  can be initialised before the model server is running; the run ends with a note
+  to re-check via `fj doctor`.
+
+## [2.0.4] — 2026-09-19
+
+### Fixed
+
+- **`fj -V` is instant (1.78s → 0.06s).** It paid the full `soothe_nano` +
+  `flowjet.core.bootstrap` import cost on every invocation just to print a
+  version string. The stdlib-only logging helpers moved out of `agent.py` into
+  `cli.py`, `main()` parses args before setting up logging so `-V`/`-h` exit
+  first, and the `-c/--config` help text now resolves lazily.
+  (`agent.py` keeps thin delegation wrappers, so existing imports and
+  monkeypatching are unaffected.)
 
 ## [2.0.3] — 2026-09-18
 

{flowjet-2.0.4 → flowjet-2.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: flowjet
-Version: 2.0.4
+Version: 2.0.5
 Summary: FlowJet — agent CLI (fj) and server (ACP + OpenAI-compatible HTTP) powered by soothe-nano
 Project-URL: Homepage, https://github.com/caesar0301/flowjet
 Project-URL: Repository, https://github.com/caesar0301/flowjet
@@ -23,7 +23,7 @@ Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: <3.15,>=3.11
 Requires-Dist: soothe-nano<1.3.0,>=1.2.28
-Requires-Dist: soothe<2.0.0,>=1.0.13
+Requires-Dist: soothe<2.0.0,>=1.0.12
 Provides-Extra: dev
 Requires-Dist: httpx>=0.27.0; extra == 'dev'
 Requires-Dist: mypy>=1.0.0; extra == 'dev'
@@ -75,7 +75,7 @@ export OPENAI_API_KEY=sk-...
 fj summarize README.md
 ```
 
-`fj setup` writes `~/.soothe/config/nano.yml`. Without it, FlowJet falls back to `OPENAI_API_KEY` or `ANTHROPIC_API_KEY`.
+`fj setup` writes `$FLOWJET_HOME/config/nano.yml` (default `~/.flowjet/config/nano.yml`). Without it, FlowJet falls back to `OPENAI_API_KEY` or `ANTHROPIC_API_KEY`.
 
 Not sure your machine is ready? `fj doctor` (add `--deep`, `--live-llm`).
 

{flowjet-2.0.4 → flowjet-2.0.5}/README.md

@@ -31,7 +31,7 @@ export OPENAI_API_KEY=sk-...
 fj summarize README.md
 ```
 
-`fj setup` writes `~/.soothe/config/nano.yml`. Without it, FlowJet falls back to `OPENAI_API_KEY` or `ANTHROPIC_API_KEY`.
+`fj setup` writes `$FLOWJET_HOME/config/nano.yml` (default `~/.flowjet/config/nano.yml`). Without it, FlowJet falls back to `OPENAI_API_KEY` or `ANTHROPIC_API_KEY`.
 
 Not sure your machine is ready? `fj doctor` (add `--deep`, `--live-llm`).
 

{flowjet-2.0.4 → flowjet-2.0.5}/docs/impl/IG-002-isolated-thread-pool-runtime.md

@@ -193,8 +193,8 @@ graph; abnormal turns recycle it before the worker is made available.
 
 | Env | Settings field | Default |
 |-----|----------------|---------|
-| `FLOWJET_HOME` | `home` | `~/.flowjet` |
-| `FLOWJET_NANO_CONFIG` | `nano_config` | unset → `$SOOTHE_HOME/config/nano.yml` |
+| `FLOWJET_HOME` | `home` | `~/.flowjet` (config file + workspaces) |
+| `FLOWJET_NANO_CONFIG` | `nano_config` | unset → `$FLOWJET_HOME/config/nano.yml` |
 | `FLOWJET_THREAD_POOL_MIN` | `thread_pool_min` | `2` |
 | `FLOWJET_THREAD_POOL_MAX` | `thread_pool_max` | `8` |
 | `FLOWJET_THREAD_POOL_IDLE_TIMEOUT` | `thread_pool_idle_timeout` | `300` |

{flowjet-2.0.4 → flowjet-2.0.5}/docs/server.md

@@ -72,8 +72,8 @@ with client.responses.stream(
 | `FLOWJET_MODELS` | `default` | Comma-separated logical model ids |
 | `FLOWJET_HOST` | `::` | Bind host (dual-stack IPv4/IPv6) |
 | `FLOWJET_PORT` | `8618` | Bind port |
-| `FLOWJET_HOME` | `~/.flowjet` | Root for per-session workspaces |
-| `FLOWJET_NANO_CONFIG` | unset | Optional `nano.yml` (else `$SOOTHE_HOME/config/nano.yml`) |
+| `FLOWJET_HOME` | `~/.flowjet` | Root for the config file (`$FLOWJET_HOME/config/nano.yml`) and per-session workspaces |
+| `FLOWJET_NANO_CONFIG` | unset | Optional `nano.yml` (else `$FLOWJET_HOME/config/nano.yml`) |
 | `FLOWJET_THREAD_POOL_MIN` | `2` | Min isolation worker threads |
 | `FLOWJET_THREAD_POOL_MAX` | `8` | Max isolation worker threads |
 | `FLOWJET_THREAD_POOL_IDLE_TIMEOUT` | `300` | Scaled-worker idle exit seconds (`0` = never) |

{flowjet-2.0.4 → flowjet-2.0.5}/examples/README.md

@@ -35,7 +35,8 @@ make examples-e2e
 ```
 
 The server uses soothe-nano with thread-pool isolation. Nano loads
-`~/.soothe/config/nano.yml` (or `FLOWJET_NANO_CONFIG`) and its active router profile.
+`$FLOWJET_HOME/config/nano.yml` (default `~/.flowjet/config/nano.yml`, or
+`FLOWJET_NANO_CONFIG`) and its active router profile.
 
 ## Environment
 

{flowjet-2.0.4 → flowjet-2.0.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "flowjet"
-version = "2.0.4"
+version = "2.0.5"
 description = "FlowJet — agent CLI (fj) and server (ACP + OpenAI-compatible HTTP) powered by soothe-nano"
 readme = "README.md"
 license = { text = "MIT" }
@@ -31,7 +31,7 @@ classifiers = [
 dependencies = [
     # Default CLI runtime (FLOWJET_BACKEND=soothe). soothe is a host layer over
     # soothe-nano, so nano stays pinned explicitly: soothe only caps it at <2.
-    "soothe>=1.0.13,<2.0.0",
+    "soothe>=1.0.12,<2.0.0",
     "soothe-nano>=1.2.28,<1.3.0",
 ]
 

{flowjet-2.0.4 → flowjet-2.0.5}/src/flowjet/cli/cli.py

@@ -44,20 +44,14 @@ class _CompactConsoleFormatter(logging.Formatter):
         return super().format(record)
 
 
-_FILE_LOGGING_INSTALLED = False
-
-
 def configure_cli_logging(*, verbose: bool = False) -> None:
-    """Quiet the console for one-shot CLI use and enable file logging by default.
+    """Quiet the console for one-shot CLI use.
 
     - Opt out of ``browser_use`` import-time root logger setup when unset.
     - Remove existing root stream handlers (stderr/stdout) so init INFO
       lines do not interleave with the agent answer.
     - Prevent ``lastResort`` traceback dumps from soothe tool failures.
     - When ``verbose``, show WARNING+ as single-line messages on stderr.
-    - Attach a rotating file handler at ``<FLOWJET_HOME>/logs/cli.log`` so
-      every CLI run is recorded by default (idempotent across re-invocations
-      within the same process, e.g. tests).
     """
     os.environ.setdefault(_BROWSER_USE_SETUP_LOGGING, "false")
     _remove_root_console_handlers()
@@ -75,25 +69,6 @@ def configure_cli_logging(*, verbose: bool = False) -> None:
     if root.level < logging.WARNING:
         root.setLevel(logging.WARNING)
 
-    _ensure_cli_file_logging()
-
-
-def _ensure_cli_file_logging() -> None:
-    """Attach the rotating file handler for CLI runs (idempotent)."""
-    global _FILE_LOGGING_INSTALLED
-    if _FILE_LOGGING_INSTALLED:
-        return
-    try:
-        from flowjet.core.home import cli_log_path, ensure_flowjet_home
-
-        ensure_flowjet_home()
-        from soothe_nano.logging.setup import setup_logging
-
-        setup_logging(log_file=str(cli_log_path()), extra_logger_names=("flowjet",))
-        _FILE_LOGGING_INSTALLED = True
-    except Exception:  # pragma: no cover - logging must never break the CLI
-        pass
-
 
 def silence_after_plugins(*, verbose: bool = False) -> None:
     """Re-apply quieting after plugin imports (belt-and-suspenders)."""
@@ -321,7 +296,7 @@ class _HelpFormatter(argparse.RawDescriptionHelpFormatter):
 
 
 def _default_config_help() -> str:
-    from flowjet.cli.agent import default_config_path
+    from flowjet.home import default_config_path
 
     return f"Alternate nano.yml (default: {default_config_path()})"
 
@@ -687,12 +662,6 @@ def main_follow(argv: list[str] | None = None) -> int:
 
 def main(argv: list[str] | None = None) -> int:
     try:
-        # Align SOOTHE_HOME with FLOWJET_HOME before any soothe import so
-        # config, data, and logs all land under ~/.flowjet. Must run first:
-        # soothe_sdk.paths binds SOOTHE_HOME at import time.
-        from flowjet.core.home import ensure_flowjet_home
-
-        ensure_flowjet_home()
         # Parse first so ``-V`` / ``-h`` / ``--help`` exit before we touch the
         # logging stack (and the heavy ``flowjet.cli.agent`` import it used to
         # drag in). Version/help must stay instant.

{flowjet-2.0.4 → flowjet-2.0.5}/src/flowjet/cli/completion/engine.py

@@ -419,13 +419,14 @@ def _split_complete_argv(raw: list[str]) -> tuple[list[str], list[str]]:
 def run_complete(argv: list[str] | None = None) -> int:
     """Hidden shell protocol: print one candidate per stdout line."""
     from flowjet.cli.cli import resolve_cli_prog
+    from flowjet.home import default_config_path
 
     parser = argparse.ArgumentParser(prog=f"{resolve_cli_prog()} __complete", add_help=True)
     parser.add_argument(
         "-c",
         "--config",
         metavar="PATH",
-        help="nano.yml path (default: ~/.soothe/config/nano.yml)",
+        help=f"nano.yml path (default: {default_config_path()})",
     )
     parser.add_argument(
         "--no-llm",

{flowjet-2.0.4 → flowjet-2.0.5}/src/flowjet/cli/doctor_cmd.py

@@ -46,8 +46,8 @@ REFERENCE_SKILLS: tuple[dict[str, Any], ...] = (
 
 
 def _build_parser() -> argparse.ArgumentParser:
-    from flowjet.cli.agent import default_config_path
     from flowjet.cli.cli import resolve_cli_prog
+    from flowjet.home import default_config_path
 
     parser = argparse.ArgumentParser(
         prog=f"{resolve_cli_prog()} doctor",

{flowjet-2.0.4 → flowjet-2.0.5}/src/flowjet/cli/setup_cmd.py

@@ -21,7 +21,7 @@ except ImportError:  # pragma: no cover - Windows
 import yaml
 from soothe_nano.config import _ENV_VAR_RE, _resolve_env
 
-from flowjet.cli.agent import default_config_path
+from flowjet.home import default_config_path, ensure_flowjet_config
 
 DEFAULT_PROVIDER_NAME = "local"
 DEFAULT_NEW_PROVIDER_NAME = "flowjet-default"
@@ -65,6 +65,10 @@ def run_setup(config_path: str | None = None) -> int:
 
 def _run_setup(config_path: str | None = None) -> int:
     path = Path(config_path).expanduser() if config_path else default_config_path()
+    if config_path is None:
+        # ``fj setup`` bypasses ``load_config``, so it pulls in a ``~/.soothe/config``
+        # copy itself before reading the provider list.
+        ensure_flowjet_config()
     existing = _load_existing_config(path)
     providers = _list_providers(existing)
     _, seed_model = _seed_from_config(existing)
@@ -100,27 +104,39 @@ def _run_setup(config_path: str | None = None) -> int:
     api_key = _prompt_secret_with_default("API key", api_key_default)
 
     sys.stdout.write("Fetching available models...\n")
+    models: list[str] = []
+    fetch_issue: str | None = None
     try:
         resolved_endpoint = resolve_config_value(endpoint, field="API endpoint")
         resolved_api_key = resolve_config_value(api_key, field="API key")
-        models = fetch_models(resolved_endpoint, resolved_api_key)
     except RuntimeError as exc:
-        sys.stderr.write(f"error: {exc}\n")
-        return 1
-
-    if not models:
-        sys.stderr.write("error: no models returned by endpoint\n")
-        return 1
-
-    preferred = seed_model
-    if selected:
-        selected_models = selected.get("models")
-        if isinstance(selected_models, list) and selected_models:
-            preferred = str(selected_models[0])
-    if preferred and preferred in models:
-        models = [preferred] + [m for m in models if m != preferred]
+        fetch_issue = str(exc)
+    else:
+        try:
+            models = fetch_models(resolved_endpoint, resolved_api_key)
+        except RuntimeError as exc:
+            fetch_issue = str(exc)
+        if not models and fetch_issue is None:
+            fetch_issue = f"{resolved_endpoint} returned no models"
+
+    if fetch_issue:
+        # An unreachable endpoint is not fatal: save the provider anyway so the
+        # user can start the model server later and pick a model by hand now.
+        sys.stderr.write(f"warning: could not list models ({fetch_issue})\n")
+        sys.stderr.write("warning: continuing without a model list\n")
+
+    if models:
+        preferred = seed_model
+        if selected:
+            selected_models = selected.get("models")
+            if isinstance(selected_models, list) and selected_models:
+                preferred = str(selected_models[0])
+        if preferred and preferred in models:
+            models = [preferred] + [m for m in models if m != preferred]
+        model = choose_model_interactive(models)
+    else:
+        model = _prompt_model_with_fallback(_fallback_model_candidates(selected, seed_model))
 
-    model = choose_model_interactive(models)
     if not model:
         sys.stderr.write("setup cancelled\n")
         return 1
@@ -139,6 +155,10 @@ def _run_setup(config_path: str | None = None) -> int:
     sys.stdout.write(f"Saved config to: {path}\n")
     sys.stdout.write(f"Active profile: {profile}\n")
     sys.stdout.write(f"Configured model: {provider_name}:{model}\n")
+    if fetch_issue:
+        sys.stdout.write(
+            "Note: model list was not verified; start the endpoint and run 'fj doctor' to confirm.\n"
+        )
     return 0
 
 
@@ -464,6 +484,45 @@ def _parse_model_filter(choice: str) -> str:
     return raw
 
 
+def _fallback_model_candidates(selected: dict[str, Any], seed_model: str | None) -> list[str]:
+    """Models already known from config, used when the endpoint cannot be queried."""
+    candidates: list[str] = []
+    if selected:
+        models = selected.get("models")
+        if isinstance(models, list):
+            candidates.extend(str(item) for item in models if str(item).strip())
+    if seed_model and seed_model not in candidates:
+        candidates.insert(0, seed_model)
+    return candidates
+
+
+def _prompt_model_with_fallback(candidates: list[str]) -> str | None:
+    """Ask for a model id directly when the endpoint has no model list to pick from."""
+    default = candidates[0] if candidates else DEFAULT_MODEL
+    if candidates:
+        sys.stdout.write("Models saved for this provider:\n")
+        for idx, name in enumerate(candidates, start=1):
+            sys.stdout.write(f"  {idx}. {name}\n")
+        label = f"Model name or number 1-{len(candidates)}"
+    else:
+        label = "Model name"
+
+    while True:
+        try:
+            value = input(f"{label} [{default}]: ").strip()
+        except EOFError:
+            return default
+        if not value:
+            return default
+        if value.isdigit() and candidates:
+            idx = int(value)
+            if 1 <= idx <= len(candidates):
+                return candidates[idx - 1]
+            sys.stdout.write(f"Invalid number; enter 1-{len(candidates)} or a model name.\n")
+            continue
+        return value
+
+
 def _load_existing_config(path: Path) -> dict[str, Any]:
     if not path.is_file():
         return {}

{flowjet-2.0.4 → flowjet-2.0.5}/src/flowjet/core/bootstrap.py

@@ -18,7 +18,7 @@ from contextlib import asynccontextmanager
 from pathlib import Path
 from typing import Any
 
-from soothe_nano.config import SOOTHE_HOME, SootheConfig
+from soothe_nano.config import SootheConfig
 from soothe_nano.resolve import resolve_checkpointer
 
 from flowjet.core.backend import Backend, resolve_backend
@@ -29,6 +29,8 @@ from flowjet.core.modes import (
     SurfaceProfile,
     require_mode,
 )
+from flowjet.home import default_config_path as _flowjet_config_path
+from flowjet.home import ensure_flowjet_config
 
 logger = logging.getLogger(__name__)
 
@@ -75,8 +77,8 @@ def register_flowjet_builtin_skills() -> None:
 
 
 def default_config_path() -> Path:
-    """Return ``~/.soothe/config/nano.yml`` (respects ``SOOTHE_HOME``)."""
-    return SOOTHE_HOME / "config" / "nano.yml"
+    """Return ``$FLOWJET_HOME/config/nano.yml`` (default ``~/.flowjet/config/nano.yml``)."""
+    return _flowjet_config_path()
 
 
 def load_config(
@@ -93,14 +95,21 @@ def load_config(
 
     Resolution order:
     1. Explicit ``config_path``
-    2. ``SOOTHE_HOME / config / nano.yml`` (default ``~/.soothe/config/nano.yml``)
+    2. ``$FLOWJET_HOME / config / nano.yml`` (default ``~/.flowjet/config/nano.yml``)
     3. Zero-config ``SootheConfig()`` from ``OPENAI_API_KEY`` / ``ANTHROPIC_API_KEY``
 
     On the ``soothe`` backend, a sibling ``soothe.yml`` (host-owned keys) is
     composed over ``nano.yml`` when present.
+
+    Without an explicit ``config_path``, a config found in ``~/.soothe/config`` is
+    copied into the flowjet home first — see :func:`flowjet.home.ensure_flowjet_config`.
     """
     backend = backend or resolve_backend(Surface.CLI)
-    path = Path(config_path).expanduser() if config_path else default_config_path()
+    if config_path is None:
+        ensure_flowjet_config()
+        path = default_config_path()
+    else:
+        path = Path(config_path).expanduser()
     if path.is_file():
         return _load_config_file(path, backend)
     if config_path is not None:

flowjet-2.0.5/src/flowjet/home.py

@@ -0,0 +1,130 @@
+"""``FLOWJET_HOME`` resolution for the config file.
+
+FlowJet reads its config from ``$FLOWJET_HOME/config/nano.yml`` (default
+``~/.flowjet/config/nano.yml``).  ``FLOWJET_HOME`` is the only authority for that
+path; ``SOOTHE_HOME`` does not affect it, and soothe-owned state — CLI data,
+logs, agents, plugins, sqlite databases — stays where the soothe runtime puts it.
+
+This module is deliberately a stdlib-only leaf: it is imported from argparse
+help builders (``fj -c``), so it must stay cheap, and it must not do file I/O
+during import or inside :func:`default_config_path`.
+
+:func:`ensure_flowjet_config` copies an existing ``~/.soothe/config`` into the
+flowjet home once, leaving the originals in place.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import shutil
+import sys
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_FLOWJET_HOME = "~/.flowjet"
+
+# Config filenames that make up a runnable flowjet setup. ``nano.yml`` is the
+# provider/router file the CLI and server read; ``soothe.yml`` is the optional
+# host-owned sibling composed over it on the ``soothe`` backend.
+_CONFIG_FILENAMES = ("nano.yml", "soothe.yml")
+
+
+def flowjet_home() -> Path:
+    """Return ``$FLOWJET_HOME`` (default ``~/.flowjet``), expanded.
+
+    Read at call time, so callers can set the env var late.
+    """
+    raw = os.environ.get("FLOWJET_HOME") or DEFAULT_FLOWJET_HOME
+    return Path(raw).expanduser()
+
+
+def legacy_soothe_home() -> Path:
+    """Return ``~/.soothe``, the home :func:`ensure_flowjet_config` copies from.
+
+    Not env-driven: the source of a copy is a fixed location, not a redirect.
+    """
+    return Path.home() / ".soothe"
+
+
+def default_config_path() -> Path:
+    """Return ``$FLOWJET_HOME/config/nano.yml``.
+
+    Pure — no directory creation, no existence checks — because argparse help
+    builders call it while rendering ``-h``.
+    """
+    return flowjet_home() / "config" / "nano.yml"
+
+
+def migrate_legacy_config(
+    *,
+    legacy_home: Path | None = None,
+    target_home: Path | None = None,
+) -> list[str]:
+    """Copy ``~/.soothe/config`` into the flowjet home, once.
+
+    No-op unless the target ``nano.yml`` is missing and the source has one, so an
+    existing flowjet config is never overwritten and this is safe to call on
+    every start.  Originals are left in place.  Returns the copied filenames.
+    """
+    legacy = Path(legacy_home) if legacy_home is not None else legacy_soothe_home()
+    target = Path(target_home) if target_home is not None else flowjet_home()
+
+    try:
+        if legacy.resolve() == target.resolve():
+            return []
+        legacy_config = legacy / "config"
+        target_config = target / "config"
+        if not (legacy_config / "nano.yml").is_file():
+            return []
+        if (target_config / "nano.yml").is_file():
+            return []
+
+        copied: list[str] = []
+        for name in _CONFIG_FILENAMES:
+            source = legacy_config / name
+            if not source.is_file():
+                continue
+            if _copy_atomic(source, target_config / name):
+                copied.append(name)
+    except OSError as exc:
+        logger.warning("could not migrate legacy config from %s: %s", legacy, exc)
+        return []
+    return copied
+
+
+def ensure_flowjet_config(
+    *,
+    legacy_home: Path | None = None,
+    target_home: Path | None = None,
+) -> list[str]:
+    """Copy a soothe-home config into the flowjet home, reporting it on stderr.
+
+    Idempotent: returns the copied filenames, empty when there was nothing to copy.
+    """
+    copied = migrate_legacy_config(legacy_home=legacy_home, target_home=target_home)
+    if copied:
+        source = Path(legacy_home) if legacy_home is not None else legacy_soothe_home()
+        target = Path(target_home) if target_home is not None else flowjet_home()
+        names = ", ".join(copied)
+        sys.stderr.write(f"Copied {names} from {source / 'config'} to {target / 'config'}\n")
+        sys.stderr.write("The original soothe config was left in place.\n")
+    return copied
+
+
+def _copy_atomic(source: Path, dest: Path) -> bool:
+    """Copy ``source`` to ``dest`` via a temp file + ``os.replace``.
+
+    Concurrent callers — server pool workers reaching this through
+    ``load_config`` — must never observe a half-written destination.
+    """
+    try:
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        tmp = dest.parent / f".{dest.name}.tmp-{os.getpid()}"
+        shutil.copyfile(source, tmp)
+        os.replace(tmp, dest)
+    except OSError as exc:
+        logger.warning("could not copy %s to %s: %s", source, dest, exc)
+        return False
+    return True

{flowjet-2.0.4 → flowjet-2.0.5}/src/flowjet/server/__main__.py

@@ -35,14 +35,12 @@ def _create_dual_stack_socket(host: str, port: int) -> socket.socket:
 
 
 def main() -> None:
-    # Align SOOTHE_HOME with FLOWJET_HOME before any soothe import so config,
-    # data, and logs all land under ~/.flowjet. Must run before Settings() or
-    # any soothe_nano import: soothe_sdk.paths binds SOOTHE_HOME at import time.
-    from flowjet.core.home import ensure_flowjet_home, setup_file_logging
+    # Pull in a ~/.soothe/config copy before the first agent build. Kept out of
+    # create_app(): the ASGI app is built at import time, and importing a module
+    # must not write files.
+    from flowjet.home import ensure_flowjet_config
 
-    ensure_flowjet_home()
-    # Record server runs to <FLOWJET_HOME>/logs/flowjet.log by default.
-    setup_file_logging(extra_logger_names=("flowjet",))
+    ensure_flowjet_config()
 
     settings = Settings()
     # When the host is a wildcard (``::`` or ``0.0.0.0``), use a dual-stack