nonoka-cli 0.2.12__tar.gz → 0.2.13__tar.gz

{nonoka_cli-0.2.12 → nonoka_cli-0.2.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nonoka-cli
-Version: 0.2.12
+Version: 0.2.13
 Summary: OpenCode backend for the Nonoka Agent framework
 License: MIT
 License-File: LICENSE
@@ -51,7 +51,23 @@ The installer will:
 1. Check Python 3.10+ and Node/npm.
 2. Install or update OpenCode.
 3. Install `nonoka-cli` and the OpenCode provider.
-4. Generate `~/.config/nonoka/config.yaml` and `~/.config/opencode/opencode.json`.
+4. Ask where to keep the installation, configuration, and npm packages.
+5. Generate the Nonoka and project-level OpenCode configuration.
+
+The prompts show what each directory contains and provide these defaults:
+
+```text
+Installation directory (Python environment, launchers, and npm tools; e.g. ~/nonoka)
+  [~/.local/share/nonoka]
+Configuration directory (config.yaml and .env; e.g. ~/.config/nonoka)
+  [~/.config/nonoka]
+npm prefix (OpenCode/provider global packages)
+  [~/.local/share/nonoka/npm]
+```
+
+Press Enter to accept a default, or type a path such as `~/tools/nonoka`.
+The generated `INSTALL_DIR/bin/nonoka` launcher remembers all three paths, so
+using its absolute path does not require any environment exports.
 
 After installing, configure your API key and run `nonoka`:
 
@@ -76,6 +92,21 @@ so you don't need to `export` every time if you save the key in `.env`.
 > To use `uv` instead of `pip`, or to run non-interactively, pass flags:
 > `curl -fsSL https://nonoka.dev/install.sh | bash -s -- --uv --yes`.
 
+For a non-interactive custom location, use flags (environment variables with
+the same names are also supported):
+
+```bash
+bash install.sh --yes --uv --npm-opencode \
+  --install-dir ~/tools/nonoka \
+  --config-dir ~/.config/nonoka \
+  --npm-prefix ~/tools/nonoka/npm
+
+~/tools/nonoka/bin/nonoka doctor
+```
+
+The corresponding variables are `NONOKA_INSTALL_DIR`, `NONOKA_CONFIG_DIR`,
+and `NONOKA_NPM_PREFIX`. CLI flags take precedence over environment variables.
+
 ## Manual installation
 
 ```bash
@@ -132,7 +163,7 @@ Example output:
 
 ```
 nonoka-cli doctor
-✓ nonoka-cli 0.2.12
+✓ nonoka-cli 0.2.13
 ✓ Python 3.11
 ✓ opencode 1.18.2
 ✓ provider nonoka-opencode-provider@0.2.17

{nonoka_cli-0.2.12 → nonoka_cli-0.2.13}/README.md

@@ -22,7 +22,23 @@ The installer will:
 1. Check Python 3.10+ and Node/npm.
 2. Install or update OpenCode.
 3. Install `nonoka-cli` and the OpenCode provider.
-4. Generate `~/.config/nonoka/config.yaml` and `~/.config/opencode/opencode.json`.
+4. Ask where to keep the installation, configuration, and npm packages.
+5. Generate the Nonoka and project-level OpenCode configuration.
+
+The prompts show what each directory contains and provide these defaults:
+
+```text
+Installation directory (Python environment, launchers, and npm tools; e.g. ~/nonoka)
+  [~/.local/share/nonoka]
+Configuration directory (config.yaml and .env; e.g. ~/.config/nonoka)
+  [~/.config/nonoka]
+npm prefix (OpenCode/provider global packages)
+  [~/.local/share/nonoka/npm]
+```
+
+Press Enter to accept a default, or type a path such as `~/tools/nonoka`.
+The generated `INSTALL_DIR/bin/nonoka` launcher remembers all three paths, so
+using its absolute path does not require any environment exports.
 
 After installing, configure your API key and run `nonoka`:
 
@@ -47,6 +63,21 @@ so you don't need to `export` every time if you save the key in `.env`.
 > To use `uv` instead of `pip`, or to run non-interactively, pass flags:
 > `curl -fsSL https://nonoka.dev/install.sh | bash -s -- --uv --yes`.
 
+For a non-interactive custom location, use flags (environment variables with
+the same names are also supported):
+
+```bash
+bash install.sh --yes --uv --npm-opencode \
+  --install-dir ~/tools/nonoka \
+  --config-dir ~/.config/nonoka \
+  --npm-prefix ~/tools/nonoka/npm
+
+~/tools/nonoka/bin/nonoka doctor
+```
+
+The corresponding variables are `NONOKA_INSTALL_DIR`, `NONOKA_CONFIG_DIR`,
+and `NONOKA_NPM_PREFIX`. CLI flags take precedence over environment variables.
+
 ## Manual installation
 
 ```bash
@@ -103,7 +134,7 @@ Example output:
 
 ```
 nonoka-cli doctor
-✓ nonoka-cli 0.2.12
+✓ nonoka-cli 0.2.13
 ✓ Python 3.11
 ✓ opencode 1.18.2
 ✓ provider nonoka-opencode-provider@0.2.17

{nonoka_cli-0.2.12 → nonoka_cli-0.2.13}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "nonoka-cli"
-version = "0.2.12"
+version = "0.2.13"
 description = "OpenCode backend for the Nonoka Agent framework"
 readme = "README.md"
 license = { text = "MIT" }

{nonoka_cli-0.2.12 → nonoka_cli-0.2.13}/src/nonoka_cli/__init__.py

@@ -2,4 +2,4 @@
 
 from __future__ import annotations
 
-__version__ = "0.2.12"
+__version__ = "0.2.13"

{nonoka_cli-0.2.12 → nonoka_cli-0.2.13}/src/nonoka_cli/cli.py

@@ -51,17 +51,29 @@ def _version() -> str:
     return "unknown"
 
 
-def _load_env_files() -> None:
+def _load_env_files(config_path: Path | str | None = None) -> None:
   """Load .env files so config env-var substitution works transparently.
 
   Priority (lowest to highest):
-  1. ~/.config/nonoka/.env
-  2. ./.env
+  1. $NONOKA_CONFIG_DIR/.env or ~/.config/nonoka/.env
+  2. the explicit config file's sibling .env
+  3. ./.env
   Existing environment variables always win.
   """
-  global_env = Path.home() / ".config" / "nonoka" / ".env"
+  configured_dir = Path(
+    os.getenv("NONOKA_CONFIG_DIR", str(Path.home() / ".config" / "nonoka"))
+  ).expanduser()
+  candidates = [configured_dir / ".env"]
+  if config_path is not None:
+    candidates.append(Path(config_path).expanduser().resolve().parent / ".env")
   local_env = Path.cwd() / ".env"
-  for path in (global_env, local_env):
+  candidates.append(local_env)
+  seen: set[Path] = set()
+  for path in candidates:
+    path = path.resolve()
+    if path in seen:
+      continue
+    seen.add(path)
     if path.exists():
       load_dotenv(dotenv_path=path, override=False)
       logger.debug("loaded_env_file", path=str(path))
@@ -140,7 +152,7 @@ def main() -> int:
 
   # Load .env files after logging is configured so the debug-only path message
   # does not leak into normal command output.
-  _load_env_files()
+  _load_env_files(args.config)
   if args.server:
     return server_main(config_path=args.config, model=args.model)
 

{nonoka_cli-0.2.12 → nonoka_cli-0.2.13}/src/nonoka_cli/commands/config_cmd.py

@@ -23,6 +23,16 @@ logger = structlog.get_logger("nonoka_cli.commands.config")
 _GLOBAL_ENV_PATH = Path.home() / ".config" / "nonoka" / ".env"
 
 
+def _env_path_for_config(config_path: Path | None) -> Path:
+  """Keep credentials beside an explicitly selected configuration file."""
+  if config_path is not None:
+    return config_path.expanduser().resolve().parent / ".env"
+  configured_dir = os.getenv("NONOKA_CONFIG_DIR")
+  if configured_dir:
+    return Path(configured_dir).expanduser().resolve() / ".env"
+  return _GLOBAL_ENV_PATH
+
+
 def _load_manager(args: argparse.Namespace) -> ConfigManager:
   """Load or create a ConfigManager from the requested path."""
   path = getattr(args, "config", None)
@@ -162,23 +172,23 @@ def _api_key_env_for_model(model: str) -> str:
   return "OPENAI_API_KEY"
 
 
-def _api_key_source_summary(env_var: str) -> str:
+def _api_key_source_summary(env_var: str, env_path: Path = _GLOBAL_ENV_PATH) -> str:
   """Return a short description of where the API key is currently sourced."""
   if os.getenv(env_var):
     return f"from environment (${env_var})"
-  if _load_env_file(_GLOBAL_ENV_PATH).get(env_var):
-    return f"from {_GLOBAL_ENV_PATH}"
+  if _load_env_file(env_path).get(env_var):
+    return f"from {env_path}"
   return ""
 
 
-def _collect_api_key(model: str) -> tuple[str, str, str]:
+def _collect_api_key(model: str, env_path: Path = _GLOBAL_ENV_PATH) -> tuple[str, str, str]:
   """Collect API key info and optionally persist it.
 
   Returns:
     (env_var_name, api_key_for_config, summary_for_user)
   """
   env_var = _api_key_env_for_model(model)
-  existing = os.getenv(env_var) or _load_env_file(_GLOBAL_ENV_PATH).get(env_var)
+  existing = os.getenv(env_var) or _load_env_file(env_path).get(env_var)
   if existing:
     print(f"Found {env_var} already set.")
     return env_var, "", f"using existing ${env_var}"
@@ -203,16 +213,17 @@ def _collect_api_key(model: str) -> tuple[str, str, str]:
     return env_var, "", "not saved"
 
   # Default: save to .env
-  _write_env_file(_GLOBAL_ENV_PATH, env_var, key_input)
+  _write_env_file(env_path, env_var, key_input)
   # Make it available for the rest of this process too.
   os.environ[env_var] = key_input
-  print(f"Saved {env_var} to {_GLOBAL_ENV_PATH}")
-  return env_var, "", f"saved to {_GLOBAL_ENV_PATH}"
+  print(f"Saved {env_var} to {env_path}")
+  return env_var, "", f"saved to {env_path}"
 
 
 def cmd_init(args: argparse.Namespace) -> int:
   """Create an initial nonoka config, interactively or with --yes defaults."""
-  path = Path(args.config) if args.config else ConfigLoader.DEFAULT_PATH
+  path = Path(args.config).expanduser() if args.config else ConfigLoader.DEFAULT_PATH
+  env_path = _env_path_for_config(path if args.config else None)
 
   print(f"Creating nonoka configuration at: {path}")
 
@@ -220,7 +231,7 @@ def cmd_init(args: argparse.Namespace) -> int:
     model = getattr(args, "model", None) or "deepseek/deepseek-v4-pro"
     auto_approve = getattr(args, "auto_approve", False)
     env_var = _api_key_env_for_model(model)
-    key_summary = _api_key_source_summary(env_var) or "not configured"
+    key_summary = _api_key_source_summary(env_var, env_path) or "not configured"
 
     config = CLIConfig(
       model=model,
@@ -240,9 +251,9 @@ def cmd_init(args: argparse.Namespace) -> int:
     print(f"Configuration saved to {path}")
     print(f"Model: {model}")
     print(f"API key ({env_var}): {key_summary}")
-    if not os.getenv(env_var) and not _load_env_file(_GLOBAL_ENV_PATH).get(env_var):
+    if not os.getenv(env_var) and not _load_env_file(env_path).get(env_var):
       print(
-        f"Set your API key with: nonoka-cli config init (interactive) "
+        f"Set your API key with: nonoka config init (interactive) "
         f"or export {env_var}=<your-key>"
       )
     return 0
@@ -254,7 +265,7 @@ def cmd_init(args: argparse.Namespace) -> int:
   )
 
   model = _read_input("Model identifier", "deepseek/deepseek-v4-pro")
-  env_var, api_key_value, key_summary = _collect_api_key(model)
+  env_var, api_key_value, key_summary = _collect_api_key(model, env_path)
 
   system_prompt = _read_input(
     "Optional system prompt",

{nonoka_cli-0.2.12 → nonoka_cli-0.2.13}/src/nonoka_cli/commands/opencode_cmd.py

@@ -304,6 +304,8 @@ def cmd_init(args: argparse.Namespace) -> int:
     sys.executable,
     "-m",
     "nonoka_cli",
+    "--config",
+    str(resolved_config_path),
     "--server",
   ]
 

{nonoka_cli-0.2.12 → nonoka_cli-0.2.13}/src/nonoka_cli/config/loader.py

@@ -15,6 +15,10 @@ from nonoka_cli.utils.errors import ConfigError, ConfigNotFoundError
 
 logger = structlog.get_logger("nonoka_cli.config")
 
+_DEFAULT_CONFIG_DIR = Path(
+  os.getenv("NONOKA_CONFIG_DIR", str(Path.home() / ".config" / "nonoka"))
+).expanduser()
+
 _ENV_PATTERN = re.compile(r"\$\{(?P<name>[A-Za-z_][A-Za-z0-9_]*)(?::-?(?P<default>[^}]*))?\}")
 
 
@@ -99,8 +103,8 @@ class ConfigLoader:
   main-config entries of the same name.
   """
 
-  DEFAULT_PATH = Path.home() / ".config" / "nonoka" / "config.yaml"
-  MCP_SERVERS_PATH = Path.home() / ".config" / "nonoka" / "mcp_servers.yaml"
+  DEFAULT_PATH = _DEFAULT_CONFIG_DIR / "config.yaml"
+  MCP_SERVERS_PATH = _DEFAULT_CONFIG_DIR / "mcp_servers.yaml"
 
   @classmethod
   def fallback_path(cls, search_dir: Path | str | None = None) -> Path:

{nonoka_cli-0.2.12 → nonoka_cli-0.2.13}/tests/unit/commands/test_cli_entrypoint.py

@@ -33,10 +33,24 @@ def test_version_flag_reports_public_command(capsys: pytest.CaptureFixture[str])
 def test_logging_is_configured_before_env_files_are_loaded(monkeypatch) -> None:
   calls: list[str] = []
   monkeypatch.setattr(cli, "setup_logging", lambda **_kwargs: calls.append("logging"))
-  monkeypatch.setattr(cli, "_load_env_files", lambda: calls.append("env"))
+  monkeypatch.setattr(cli, "_load_env_files", lambda *_args: calls.append("env"))
   monkeypatch.setattr(cli.run_cmd, "launch_tui", lambda _args: 0)
 
   with patch.object(cli.sys, "argv", ["nonoka"]):
     assert cli.main() == 0
 
   assert calls == ["logging", "env"]
+
+
+def test_explicit_config_loads_sibling_env(tmp_path, monkeypatch) -> None:
+  config_path = tmp_path / "custom" / "config.yaml"
+  env_path = config_path.parent / ".env"
+  env_path.parent.mkdir()
+  env_path.write_text("DEEPSEEK_API_KEY=test-only\n")
+  loaded: list[str] = []
+  monkeypatch.setattr(cli, "load_dotenv", lambda dotenv_path, override: loaded.append(str(dotenv_path)))
+  monkeypatch.chdir(tmp_path)
+
+  cli._load_env_files(config_path)
+
+  assert str(env_path.resolve()) in loaded

{nonoka_cli-0.2.12 → nonoka_cli-0.2.13}/tests/unit/commands/test_config_cmd.py

@@ -74,7 +74,6 @@ def test_write_env_file(tmp_path: Path):
 def test_config_init_saves_api_key_to_env(tmp_path: Path, monkeypatch):
   config_path = tmp_path / "config.yaml"
   env_path = tmp_path / ".env"
-  monkeypatch.setattr(config_cmd, "_GLOBAL_ENV_PATH", env_path)
 
   inputs = iter(["deepseek-chat", "", "d", ""])
   def fake_read_input(prompt: str, default: str = "") -> str:
@@ -97,3 +96,10 @@ def test_config_init_saves_api_key_to_env(tmp_path: Path, monkeypatch):
 
   # Clean up so the key does not leak into other tests.
   monkeypatch.delenv("DEEPSEEK_API_KEY", raising=False)
+
+
+def test_config_init_uses_configured_directory_for_default_env(tmp_path: Path, monkeypatch):
+  config_dir = tmp_path / "configured"
+  monkeypatch.setenv("NONOKA_CONFIG_DIR", str(config_dir))
+
+  assert config_cmd._env_path_for_config(None) == config_dir / ".env"

{nonoka_cli-0.2.12 → nonoka_cli-0.2.13}/tests/unit/commands/test_opencode_cmd.py

@@ -53,7 +53,7 @@ def test_opencode_init_creates_file(tmp_path: Path):
   assert data["provider"]["nonoka"]["options"]["requireFocusedVerification"] is True
   assert data["provider"]["nonoka"]["options"]["verificationEnforcement"] == "strict"
   assert data["provider"]["nonoka"]["options"]["serverCommand"] == [
-    sys.executable, "-m", "nonoka_cli", "--server",
+    sys.executable, "-m", "nonoka_cli", "--config", str(config_path), "--server",
   ]
 
 
@@ -77,7 +77,7 @@ def test_opencode_init_merges_existing(tmp_path: Path):
   assert data["custom"] is True
   assert data["provider"]["nonoka"]["options"]["configPath"] == str(config_path)
   assert data["provider"]["nonoka"]["options"]["serverCommand"] == [
-    sys.executable, "-m", "nonoka_cli", "--server",
+    sys.executable, "-m", "nonoka_cli", "--config", str(config_path), "--server",
   ]
 
 

{nonoka_cli-0.2.12 → nonoka_cli-0.2.13}/tests/unit/config/test_loader.py

@@ -8,6 +8,10 @@ from nonoka_cli.config.loader import ConfigLoader, _substitute_env_vars
 from nonoka_cli.utils.errors import ConfigError, ConfigNotFoundError
 
 
+def test_default_config_assets_share_configured_directory():
+  assert ConfigLoader.MCP_SERVERS_PATH.parent == ConfigLoader.DEFAULT_PATH.parent
+
+
 def test_substitute_env_vars_with_default():
   value = _substitute_env_vars("${UNSET_VAR:-default_value}")
   assert value == "default_value"

nonoka_cli-0.2.13/tests/unit/test_install_script.py

@@ -0,0 +1,200 @@
+"""Offline behavioural tests for install.sh path selection."""
+
+from __future__ import annotations
+
+import os
+import subprocess
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[2]
+INSTALLER = ROOT / "install.sh"
+
+
+def _command(path: Path, body: str) -> None:
+  path.write_text("#!/usr/bin/env bash\nset -e\n" + body, encoding="utf-8")
+  path.chmod(0o755)
+
+
+def _fake_environment(tmp_path: Path) -> tuple[dict[str, str], Path]:
+  fake_bin = tmp_path / "bin"
+  fake_bin.mkdir()
+  log = tmp_path / "calls.log"
+  _command(fake_bin / "python3", "printf '3.13\\n'\n")
+  _command(
+    fake_bin / "uv",
+    'printf "uv:%s\\n" "$*" >> "$NONOKA_TEST_LOG"\n'
+    'if [ "${1:-}" = venv ]; then\n'
+    '  mkdir -p "$2/bin"\n'
+    '  touch "$2/bin/python"\n'
+    '  chmod +x "$2/bin/python"\n'
+    '  cp "$(dirname "$0")/nonoka" "$2/bin/nonoka"\n'
+    'fi\n',
+  )
+  _command(fake_bin / "opencode", "printf '1.18.10\\n'\n")
+  _command(fake_bin / "npm", 'printf "npm:%s\\n" "$*" >> "$NONOKA_TEST_LOG"\n')
+  _command(fake_bin / "nonoka", 'printf "nonoka:%s\\n" "$*" >> "$NONOKA_TEST_LOG"\n')
+  _command(fake_bin / "curl", "exit 0\n")
+
+  env = os.environ.copy()
+  env.update(
+    {
+      "HOME": str(tmp_path / "home"),
+      "PATH": f"{fake_bin}:/usr/bin:/bin",
+      "NONOKA_TEST_LOG": str(log),
+    }
+  )
+  for name in (
+    "VIRTUAL_ENV",
+    "NONOKA_INSTALL_DIR",
+    "NONOKA_CONFIG_DIR",
+    "NONOKA_NPM_PREFIX",
+  ):
+    env.pop(name, None)
+  return env, log
+
+
+def _run(tmp_path: Path, *args: str, input_text: str | None = None, env=None):
+  return subprocess.run(
+    ["bash", str(INSTALLER), *args],
+    cwd=tmp_path,
+    env=env,
+    input=input_text,
+    text=True,
+    capture_output=True,
+    timeout=20,
+    check=False,
+  )
+
+
+def test_install_dir_flags_expand_home_and_drive_all_commands(tmp_path: Path) -> None:
+  env, log = _fake_environment(tmp_path)
+  result = _run(
+    tmp_path,
+    "--yes",
+    "--uv",
+    "--no-opencode",
+    "--install-dir",
+    "~/chosen-install",
+    "--config-dir",
+    "~/chosen-config",
+    "--npm-prefix",
+    "~/chosen-npm",
+    env=env,
+  )
+
+  assert result.returncode == 0, result.stderr
+  home = Path(env["HOME"])
+  calls = log.read_text()
+  assert f"uv:venv {home}/chosen-install/.venv --python python3" in calls
+  assert "uv:pip install --upgrade nonoka-cli" in calls
+  assert f"nonoka:config init --yes --config {home}/chosen-config/config.yaml" in calls
+  assert f"nonoka:init --config {home}/chosen-config/config.yaml" in calls
+  assert f"npm prefix: {home}/chosen-npm" in result.stdout
+
+
+def test_environment_variables_select_noninteractive_layout(tmp_path: Path) -> None:
+  env, log = _fake_environment(tmp_path)
+  env.update(
+    {
+      "NONOKA_INSTALL_DIR": str(tmp_path / "env-install"),
+      "NONOKA_CONFIG_DIR": str(tmp_path / "env-config"),
+      "NONOKA_NPM_PREFIX": str(tmp_path / "env-npm"),
+    }
+  )
+
+  result = _run(tmp_path, "--yes", "--uv", "--no-opencode", env=env)
+
+  assert result.returncode == 0, result.stderr
+  calls = log.read_text()
+  assert f"uv:venv {tmp_path}/env-install/.venv --python python3" in calls
+  assert f"nonoka:config init --yes --config {tmp_path}/env-config/config.yaml" in calls
+  assert f"npm prefix: {tmp_path}/env-npm" in result.stdout
+
+
+def test_interactive_prompts_explain_each_directory(tmp_path: Path) -> None:
+  env, log = _fake_environment(tmp_path)
+  selected_install = tmp_path / "interactive-install"
+  selected_config = tmp_path / "interactive-config"
+  selected_npm = tmp_path / "interactive-npm"
+  answers = f"{selected_install}\n{selected_config}\n{selected_npm}\n"
+
+  result = _run(tmp_path, "--uv", "--no-opencode", input_text=answers, env=env)
+
+  assert result.returncode == 0, result.stderr
+  assert "Installation directory (Python environment, launchers, and npm tools" in result.stderr
+  assert "Configuration directory (config.yaml and .env" in result.stderr
+  assert "npm prefix (OpenCode/provider global packages)" in result.stderr
+  calls = log.read_text()
+  assert f"uv:venv {selected_install}/.venv --python python3" in calls
+  assert f"nonoka:config init --config {selected_config}/config.yaml" in calls
+
+
+def test_interactive_defaults_are_displayed_with_tilde(tmp_path: Path) -> None:
+  env, _log = _fake_environment(tmp_path)
+
+  result = _run(
+    tmp_path,
+    "--uv",
+    "--no-opencode",
+    input_text="\n\n\n",
+    env=env,
+  )
+
+  assert result.returncode == 0, result.stderr
+  assert "[~/.local/share/nonoka]" in result.stderr
+  assert "[~/.config/nonoka]" in result.stderr
+  assert "[~/.local/share/nonoka/npm]" in result.stderr
+
+
+def test_launcher_preserves_paths_with_spaces_and_needs_no_exports(tmp_path: Path) -> None:
+  env, _log = _fake_environment(tmp_path)
+  install_dir = tmp_path / "install with spaces"
+  config_dir = tmp_path / "config with spaces"
+  npm_prefix = tmp_path / "npm with spaces"
+
+  result = _run(
+    tmp_path,
+    "--yes",
+    "--uv",
+    "--no-opencode",
+    "--install-dir",
+    str(install_dir),
+    "--config-dir",
+    str(config_dir),
+    "--npm-prefix",
+    str(npm_prefix),
+    env=env,
+  )
+
+  assert result.returncode == 0, result.stderr
+  launcher = install_dir / "bin" / "nonoka"
+  alias = install_dir / "bin" / "nonoka-cli"
+  assert launcher.is_file()
+  assert os.access(launcher, os.X_OK)
+  assert alias.is_symlink()
+  assert os.readlink(alias) == "nonoka"
+
+  clean_env = env.copy()
+  clean_env.pop("VIRTUAL_ENV", None)
+  clean_env.pop("NONOKA_CONFIG_DIR", None)
+  clean_env.pop("NPM_CONFIG_PREFIX", None)
+  invoked = subprocess.run(
+    [str(launcher), "doctor"],
+    env=clean_env,
+    text=True,
+    capture_output=True,
+    timeout=10,
+    check=False,
+  )
+  assert invoked.returncode == 0, invoked.stderr
+  calls = (tmp_path / "calls.log").read_text()
+  assert "nonoka:doctor" in calls
+
+  content = launcher.read_text(encoding="utf-8")
+  escaped_venv = str(install_dir / ".venv").replace(" ", "\\ ")
+  escaped_config = str(config_dir).replace(" ", "\\ ")
+  escaped_npm = str(npm_prefix).replace(" ", "\\ ")
+  assert f"export VIRTUAL_ENV={escaped_venv}" in content
+  assert f"export NONOKA_CONFIG_DIR={escaped_config}" in content
+  assert f"export NPM_CONFIG_PREFIX={escaped_npm}" in content