stackops 8.102__tar.gz → 8.104__tar.gz

{stackops-8.102 → stackops-8.104}/MANIFEST.in

@@ -3,3 +3,4 @@ graft src/stackops/settings
 graft src/stackops/jobs
 graft src/stackops/profile
 graft src/stackops/scripts
+graft src/stackops/utils/schemas

{stackops-8.102/src/stackops.egg-info → stackops-8.104}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stackops
-Version: 8.102
+Version: 8.104
 Summary: Developer Stack Manager
 Author-email: Alex Al-Saffar <programmer@usa.com>
 License: Apache 2.0

{stackops-8.102 → stackops-8.104}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "stackops"
-version = "8.102"
+version = "8.104"
 description = "Developer Stack Manager"
 readme = "README.md"
 license = {text = "Apache 2.0"}
@@ -51,7 +51,7 @@ cloud = "stackops.scripts.python.cloud:main"
 fire = "stackops.scripts.python.fire_jobs:main"
 agents = "stackops.scripts.python.agents:main"
 terminal = "stackops.scripts.python.terminal:main"
-croshell = "stackops.scripts.python.croshell:main"
+preview = "stackops.scripts.python.preview:main"
 utils = "stackops.scripts.python.utils:main"
 stackops = "stackops.scripts.python.stackops_entry:main"
 seek = "stackops.scripts.python.seek:main"
@@ -65,7 +65,7 @@ license-files = []
 where = ["src"]
 
 [tool.setuptools.package-data]
-stackops = ["**/*.toml", "**/*.md", "**/*.sh", "**/*.ps1", "**/*.txt", "utils/schemas/**/*.json"]
+stackops = ["**/*.toml", "**/*.md", "**/*.sh", "**/*.ps1", "**/*.txt", "utils/schemas/**/*.json", "utils/schemas/**/*.yaml"]
 
 [dependency-groups]
 dev = [

stackops-8.104/src/manual/test_cli_config_secrets.py

@@ -0,0 +1,259 @@
+import json
+from inspect import Parameter, signature
+from pathlib import Path
+from typing import get_args
+
+import pytest
+from typer.testing import CliRunner
+
+from stackops.scripts.python.helpers.helpers_devops import cli_config, cli_config_secrets
+
+
+def test_config_secrets_is_nested_typer_app() -> None:
+    runner = CliRunner()
+
+    result = runner.invoke(cli_config.get_app(), ["secrets", "--help"])
+
+    assert result.exit_code == 0
+    assert "Usage: root secrets [OPTIONS] COMMAND [ARGS]..." in result.output
+    assert "search" in result.output
+    assert "stats" in result.output
+    assert "subset" in result.output
+    assert "add" in result.output
+    assert "edit" in result.output
+    assert "Examples:" not in result.output
+
+
+def test_config_secrets_search_help_has_examples() -> None:
+    runner = CliRunner()
+
+    result = runner.invoke(cli_config.get_app(), ["secrets", "search", "--help"])
+
+    assert result.exit_code == 0
+    assert "Usage: root secrets search [OPTIONS] [TERMS]..." in result.output
+    assert "Examples:" in result.output
+    assert "devops config secrets search aws dev iam-access-key" in result.output
+    assert "devops config secrets add" not in result.output
+    assert "devops config secrets edit" not in result.output
+
+
+def test_secrets_search_keeps_selector_aliases() -> None:
+    parameters = signature(cli_config_secrets.search).parameters
+    expected_aliases = {
+        "secrets_path": "-p",
+        "secrets_source": "-s",
+        "interactive": "-i",
+        "preview_secrets": "-P",
+        "verbose": "-v",
+        "login_name": "-n",
+        "secret_name": "-N",
+        "tags": "-t",
+        "login_tags": "-l",
+        "secret_tags": "-T",
+        "scopes": "-S",
+        "keys": "-k",
+    }
+
+    for parameter_name, alias in expected_aliases.items():
+        assert alias in _option_param_decls(parameters[parameter_name])
+    assert "add" not in parameters
+    assert "edit" not in parameters
+    assert "create" not in parameters
+    assert "editor" not in parameters
+
+
+def test_secrets_add_and_edit_have_short_aliases() -> None:
+    stats_parameters = signature(cli_config_secrets.stats).parameters
+    subset_parameters = signature(cli_config_secrets.subset).parameters
+    add_parameters = signature(cli_config_secrets.add).parameters
+    edit_parameters = signature(cli_config_secrets.edit).parameters
+
+    assert "-p" in _option_param_decls(stats_parameters["secrets_path"])
+    assert "-s" in _option_param_decls(stats_parameters["secrets_source"])
+    assert "-d" in _option_param_decls(stats_parameters["details"])
+    assert "-o" in _option_param_decls(subset_parameters["output_path"])
+    assert "-p" in _option_param_decls(subset_parameters["secrets_path"])
+    assert "-s" in _option_param_decls(subset_parameters["secrets_source"])
+    assert "-f" in _option_param_decls(subset_parameters["overwrite"])
+    assert "-p" in _option_param_decls(add_parameters["secrets_path"])
+    assert "-s" in _option_param_decls(add_parameters["secrets_source"])
+    assert "-p" in _option_param_decls(edit_parameters["secrets_path"])
+    assert "-s" in _option_param_decls(edit_parameters["secrets_source"])
+    assert "-E" in _option_param_decls(edit_parameters["editor"])
+
+
+def test_secrets_search_writes_selected_env_handoff(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    secrets_path = tmp_path / "secrets.json"
+    secrets_path.write_text(
+        json.dumps(
+            {
+                "version": "0.5",
+                "entries": [
+                    {
+                        "name": "aws-dev",
+                        "tags": ["aws", "dev"],
+                        "secrets": [
+                            {
+                                "name": "iam-access-key",
+                                "tags": ["iam-access-key"],
+                                "scopes": ["aws"],
+                                "keyValues": {"AWS_ACCESS_KEY_ID": "dummy-key"},
+                            }
+                        ],
+                    }
+                ],
+            }
+        ),
+        encoding="utf-8",
+    )
+    handoff: list[dict[str, object]] = []
+    monkeypatch.setattr(cli_config_secrets.secret_actions, "write_env_handoff", handoff.append)
+
+    cli_config_secrets.search(terms=["aws", "dev"], secrets_path=secrets_path, secrets_source="local")
+
+    assert handoff == [{"AWS_ACCESS_KEY_ID": "dummy-key"}]
+
+
+def test_secrets_stats_uses_aggregate_tables_without_secret_values(tmp_path: Path) -> None:
+    secrets_path = tmp_path / "secrets.json"
+    secrets_path.write_text(
+        json.dumps(
+            {
+                "version": "0.5",
+                "entries": [
+                    {
+                        "name": "service-login",
+                        "tags": ["team-a"],
+                        "description": "Used by service tests",
+                        "secrets": [
+                            {
+                                "name": "service-token",
+                                "tags": ["api"],
+                                "scopes": ["ci"],
+                                "keyValues": {
+                                    "SERVICE_TOKEN": "super-secret-token",
+                                    "SERVICE_PAYLOAD": {"nested": "do-not-print"},
+                                },
+                                "rotation": {"lastRotated": "2026-01-01", "rotateEveryDays": 90},
+                            }
+                        ],
+                    }
+                ],
+            }
+        ),
+        encoding="utf-8",
+    )
+    runner = CliRunner()
+
+    result = runner.invoke(cli_config_secrets.get_app(), ["stats", "--path", str(secrets_path), "--source", "local"])
+
+    assert result.exit_code == 0
+    assert "StackOps Secrets Sources" in result.output
+    assert "Inventory Totals" in result.output
+    assert "Metadata Coverage" in result.output
+    assert "Env Vars" in result.output
+    assert "2" in result.output
+    assert str(secrets_path) not in result.output
+    assert "super-secret-token" not in result.output
+    assert "do-not-print" not in result.output
+    assert "SERVICE_TOKEN" not in result.output
+    assert "service-login" not in result.output
+    assert "service-token" not in result.output
+
+
+def test_secrets_subset_writes_selected_entries_without_printing_secret_values(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    secrets_path = tmp_path / "source-secrets.json"
+    output_path = tmp_path / "subset" / "secrets.json"
+    secrets_path.write_text(
+        json.dumps(
+            {
+                "$schema": "./secrets.schema.json",
+                "version": "0.5",
+                "entries": [
+                    {
+                        "name": "first-login",
+                        "tags": ["team-a"],
+                        "secrets": [
+                            {
+                                "name": "first-token",
+                                "tags": ["api"],
+                                "scopes": ["dev"],
+                                "keyValues": {"FIRST_TOKEN": "first-secret-value"},
+                            }
+                        ],
+                    },
+                    {
+                        "name": "second-login",
+                        "tags": ["team-b"],
+                        "secrets": [
+                            {
+                                "name": "second-token",
+                                "tags": ["api"],
+                                "scopes": ["prod"],
+                                "keyValues": {"SECOND_TOKEN": "second-secret-value"},
+                            }
+                        ],
+                    },
+                ],
+            }
+        ),
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(cli_config_secrets.secret_actions, "_choose_subset_login_indices", lambda secrets_file: [1])
+    runner = CliRunner()
+
+    result = runner.invoke(
+        cli_config_secrets.get_app(),
+        ["subset", "--path", str(secrets_path), "--source", "local", "--output", str(output_path)],
+    )
+
+    assert result.exit_code == 0
+    assert "second-secret-value" not in result.output
+    subset_payload = json.loads(output_path.read_text(encoding="utf-8"))
+    assert subset_payload["$schema"] == "./secrets.schema.json"
+    assert subset_payload["version"] == "0.5"
+    assert [entry["name"] for entry in subset_payload["entries"]] == ["second-login"]
+    assert subset_payload["entries"][0]["secrets"][0]["keyValues"] == {"SECOND_TOKEN": "second-secret-value"}
+
+
+def test_secrets_subset_refuses_to_overwrite_by_default(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    secrets_path = tmp_path / "source-secrets.json"
+    output_path = tmp_path / "subset-secrets.json"
+    secrets_path.write_text(
+        json.dumps(
+            {
+                "version": "0.5",
+                "entries": [
+                    {
+                        "name": "service-login",
+                        "secrets": [
+                            {
+                                "name": "service-token",
+                                "keyValues": {"SERVICE_TOKEN": "source-secret-value"},
+                            }
+                        ],
+                    }
+                ],
+            }
+        ),
+        encoding="utf-8",
+    )
+    output_path.write_text("existing\n", encoding="utf-8")
+    monkeypatch.setattr(cli_config_secrets.secret_actions, "_choose_subset_login_indices", lambda secrets_file: [0])
+    runner = CliRunner()
+
+    result = runner.invoke(
+        cli_config_secrets.get_app(),
+        ["subset", "--path", str(secrets_path), "--source", "local", "--output", str(output_path)],
+    )
+
+    assert result.exit_code == 1
+    assert output_path.read_text(encoding="utf-8") == "existing\n"
+
+
+def _option_param_decls(parameter: Parameter) -> tuple[str, ...]:
+    for metadata in get_args(parameter.annotation)[1:]:
+        param_decls = getattr(metadata, "param_decls", ())
+        if param_decls:
+            return tuple(param_decls)
+    raise AssertionError(f"Parameter has no Typer option metadata: {parameter.name}")

stackops-8.104/src/manual/test_cli_self_docker.py

@@ -0,0 +1,151 @@
+import json
+from inspect import Parameter, signature
+from pathlib import Path
+from typing import get_args
+
+import pytest
+
+from stackops.scripts.python.helpers.helpers_devops import cli_self, cli_self_docker
+
+
+def test_build_docker_options_have_one_letter_aliases() -> None:
+    parameters = signature(cli_self.build_docker).parameters
+    expected_aliases = {
+        "docker_login_name": "-n",
+        "docker_account_name": "-a",
+        "docker_secret_name": "-N",
+        "docker_secret_tags": "-T",
+        "docker_scopes": "-S",
+        "docker_token_key": "-k",
+        "docker_secrets_path": "-p",
+    }
+
+    for parameter_name, alias in expected_aliases.items():
+        assert alias in _option_param_decls(parameters[parameter_name])
+    assert parameters["docker_login_name"].default == "docker"
+    assert "docker_tags" not in parameters
+    assert "docker_login_tags" not in parameters
+
+
+def test_docker_credentials_use_login_username(monkeypatch: pytest.MonkeyPatch) -> None:
+    calls: list[dict[str, object]] = []
+
+    def fake_search_logins(**kwargs: object) -> list[dict[str, object]]:
+        calls.append(kwargs)
+        if kwargs["keys"] != ("DOCKER_TOKEN",):
+            return []
+        return [
+            {
+                "name": "docker",
+                "tags": ["docker"],
+                "username": "alice",
+                "secrets": [
+                    {
+                        "name": "publish",
+                        "tags": ["docker"],
+                        "scopes": ["docker"],
+                        "keyValues": {"DOCKER_TOKEN": "dummy-token"},
+                    }
+                ],
+            }
+        ]
+
+    monkeypatch.setattr(cli_self_docker, "search_logins", fake_search_logins)
+
+    credentials = cli_self_docker.resolve_docker_credentials(
+        secrets_path=None,
+        login_name=None,
+        account_name=None,
+        secret_name=None,
+        secret_tags=None,
+        scopes=None,
+        token_key=None,
+    )
+
+    assert credentials.username == "alice"
+    assert credentials.token_env_key == "DOCKER_TOKEN"
+    assert credentials.key_values == {"DOCKER_TOKEN": "dummy-token"}
+    assert calls[0]["login_name"] == "docker"
+
+
+def test_docker_credentials_resolve_through_search_logins_with_temp_file(tmp_path: Path) -> None:
+    secrets_path = tmp_path / "secrets.json"
+    secrets_path.write_text(
+        json.dumps(
+            {
+                "version": "0.5",
+                "entries": [
+                    {
+                        "name": "docker",
+                        "tags": ["docker"],
+                        "username": "alice",
+                        "secrets": [
+                            {
+                                "name": "publish",
+                                "tags": ["docker"],
+                                "scopes": ["docker"],
+                                "keyValues": {"DOCKER_TOKEN": "dummy-token"},
+                            }
+                        ],
+                    }
+                ],
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    credentials = cli_self_docker.resolve_docker_credentials(
+        secrets_path=secrets_path,
+        login_name=None,
+        account_name=None,
+        secret_name=None,
+        secret_tags=None,
+        scopes=None,
+        token_key=None,
+    )
+
+    assert credentials.login_name == "docker"
+    assert credentials.secret_name == "publish"
+    assert credentials.username == "alice"
+    assert credentials.token_env_key == "DOCKER_TOKEN"
+
+
+def test_rendered_docker_handoff_script_does_not_include_secret_values(tmp_path: Path) -> None:
+    script = cli_self_docker.render_build_docker_shell_script(
+        variant="slim",
+        repo_root=tmp_path / "repo",
+        script_path=tmp_path / "repo/jobs/shell/docker_build_and_publish.sh",
+        secret_env_path=tmp_path / "handoff.docker.secrets.env.sh",
+        docker_username="alice",
+        token_env_key="DOCKER_TOKEN",
+        credential_env_keys=("DOCKER_TOKEN",),
+    )
+
+    assert "dummy-token" not in script
+    assert "statistician" not in script
+    assert "export DOCKER_IMAGE_NAMESPACE=alice" in script
+    assert "export DOCKER_LOGIN_TOKEN_ENV_VAR=DOCKER_TOKEN" in script
+    assert "unset DOCKER_TOKEN" in script
+
+
+def test_docker_publish_script_no_longer_hardcodes_namespace() -> None:
+    script = Path("jobs/shell/docker_build_and_publish.sh").read_text(encoding="utf-8")
+
+    assert "statistician" not in script
+    assert "DOCKER_IMAGE_NAMESPACE" in script
+    assert "docker login" in script
+
+
+def test_docker_helper_module_does_not_import_typer() -> None:
+    script = Path("src/stackops/scripts/python/helpers/helpers_devops/cli_self_docker.py").read_text(encoding="utf-8")
+
+    assert "import typer" not in script
+    assert "typer." not in script
+
+
+def _option_param_decls(parameter: Parameter) -> tuple[str, ...]:
+    for metadata in get_args(parameter.annotation)[1:]:
+        param_decls = getattr(metadata, "param_decls", ())
+        if param_decls:
+            return tuple(param_decls)
+    raise AssertionError(f"Parameter has no Typer option metadata: {parameter.name}")

stackops-8.104/src/manual/test_herdr_backend.py

@@ -0,0 +1,86 @@
+from subprocess import CompletedProcess
+
+import pytest
+
+from stackops.scripts.python.helpers.helpers_sessions import _herdr_backend as herdr
+
+
+def _completed(args: list[str], stdout: str, returncode: int = 0) -> CompletedProcess[str]:
+    return CompletedProcess(args=args, returncode=returncode, stdout=stdout, stderr="")
+
+
+def test_choose_named_session_uses_herdr_attach() -> None:
+    assert herdr.choose_session(name="default", new_session=False, kill_all=False) == (
+        "handoff_script",
+        "herdr session attach default",
+    )
+
+
+def test_new_session_uses_generated_herdr_session_name(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(herdr, "_new_session_name", lambda: "stackops-test")
+
+    assert herdr.new_session_script(kill_all=False) == "herdr --session stackops-test"
+
+
+def test_kill_all_stops_running_sessions(monkeypatch: pytest.MonkeyPatch) -> None:
+    sessions = [
+        {"name": "default", "running": True},
+        {"name": "stopped", "running": False},
+        {"name": "agent work", "running": True},
+    ]
+    monkeypatch.setattr(herdr, "_session_entries", lambda: sessions)
+
+    assert herdr.choose_kill_target(name=None, kill_all=True) == (
+        "run_script",
+        "herdr session stop default --json\nherdr session stop 'agent work' --json",
+    )
+
+
+def test_window_selection_builds_tab_and_pane_attach_scripts(monkeypatch: pytest.MonkeyPatch) -> None:
+    def fake_run_command(args: list[str], timeout: float = 5.0) -> CompletedProcess[str]:
+        _ = timeout
+        if args == ["herdr", "--session", "default", "tab", "list"]:
+            return _completed(
+                args,
+                (
+                    '{"result":{"tabs":['
+                    '{"tab_id":"workspace:1","number":1,"label":"main","focused":true}'
+                    ']}}'
+                ),
+            )
+        if args == ["herdr", "--session", "default", "pane", "list"]:
+            return _completed(
+                args,
+                (
+                    '{"result":{"panes":['
+                    '{"pane_id":"pane-1","terminal_id":"term-1","tab_id":"workspace:1",'
+                    '"label":"codex","focused":false}'
+                    ']}}'
+                ),
+            )
+        return _completed(args, "{}", returncode=1)
+
+    monkeypatch.setattr(herdr, "run_command", fake_run_command)
+    monkeypatch.setattr(
+        herdr,
+        "_session_entries",
+        lambda: [{"name": "default", "running": True, "default": True}],
+    )
+    monkeypatch.setattr(
+        herdr,
+        "interactive_choose_with_preview",
+        lambda msg, options_to_preview_mapping, multi=False: "[default] 1:main / codex",
+    )
+
+    action, script = herdr.choose_session(
+        name=None,
+        new_session=False,
+        kill_all=False,
+        window=True,
+    )
+
+    assert action == "handoff_script"
+    assert script == (
+        "herdr --session default agent focus term-1\n"
+        "herdr session attach default"
+    )

stackops-8.104/src/manual/test_path_references.py

@@ -0,0 +1,18 @@
+
+
+from pathlib import Path
+
+import pytest
+
+from stackops.scripts.python.helpers.helpers_utils.path_reference_validation import audit_repository_path_references, format_path_reference_audit
+
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+
+
+def test_all_path_reference_targets_exist(capsys: pytest.CaptureFixture[str]) -> None:
+    audit = audit_repository_path_references(repo_path=REPO_ROOT, search_root=None)
+    with capsys.disabled():
+        print(f"Picked up {audit.reference_count} _PATH_REFERENCE variables.")
+    if audit.has_failures():
+        pytest.fail(format_path_reference_audit(audit=audit))

stackops-8.104/src/manual/test_secrets_schema.py

@@ -0,0 +1,47 @@
+import json
+from pathlib import Path
+
+import pytest
+
+from stackops.utils.schemas.secrets.secrets_loader import SecretsSchemaError, load_secrets_file
+from stackops.utils.schemas.secrets.secrets_types import SecretRecord
+
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+SECRETS_SCHEMA_PATH = REPO_ROOT / "src" / "stackops" / "utils" / "schemas" / "secrets" / "secrets.schema.json"
+SECRETS_EXAMPLE_PATH = REPO_ROOT / "src" / "stackops" / "utils" / "schemas" / "secrets" / "secrets.example.json"
+
+
+def test_loader_requires_secret_name(tmp_path: Path) -> None:
+    secrets_path = tmp_path / "secrets.json"
+    secrets_path.write_text(
+        json.dumps({"version": "0.5", "entries": [{"name": "service", "secrets": [{"keyValues": {"TOKEN": "redacted"}}]}]}), encoding="utf-8"
+    )
+
+    with pytest.raises(SecretsSchemaError, match=r"entries\[0\]\.secrets\[0\]\.name must be a non-empty string"):
+        load_secrets_file(secrets_path)
+
+
+def test_loaded_secret_name_is_required_type(tmp_path: Path) -> None:
+    secrets_path = tmp_path / "secrets.json"
+    secrets_path.write_text(
+        json.dumps({"version": "0.5", "entries": [{"name": "service", "secrets": [{"name": "api-token", "keyValues": {"TOKEN": "redacted"}}]}]}),
+        encoding="utf-8",
+    )
+
+    loaded = load_secrets_file(secrets_path)
+    secret: SecretRecord = loaded["entries"][0]["secrets"][0]
+
+    assert secret["name"] == "api-token"
+
+
+def test_schema_requires_secret_name() -> None:
+    schema = json.loads(SECRETS_SCHEMA_PATH.read_text(encoding="utf-8"))
+
+    assert schema["definitions"]["secret"]["required"] == ["name", "keyValues"]
+
+
+def test_packaged_example_secret_entries_have_names() -> None:
+    example = json.loads(SECRETS_EXAMPLE_PATH.read_text(encoding="utf-8"))
+
+    assert all("name" in secret for entry in example["entries"] for secret in entry["secrets"])

{stackops-8.102 → stackops-8.104}/src/stackops/cluster/remote/cloud_manager.py

@@ -13,8 +13,8 @@ from rich.console import Console
 from stackops.cluster.remote.models import JOB_STATUS, LogEntry
 from stackops.utils import rclone as rclone_utils
 from stackops.utils.files.read import read_json
-from stackops.utils.io import read_ini, save_json
-from stackops.utils.source_of_truth import DEFAULTS_PATH
+from stackops.utils.io import save_json
+from stackops.utils.source_of_truth import read_stackops_config_string
 
 
 LOCK_EXPIRY_SECONDS = 3600
@@ -59,7 +59,7 @@ class CloudManager:
         self.status_root = status_root
         self.max_jobs = max_jobs
         if cloud is None:
-            self.cloud = str(read_ini(DEFAULTS_PATH)["general"]["rclone_config_name"])
+            self.cloud = read_stackops_config_string("default_rclone_config")
         else:
             self.cloud = cloud
         self.lock_claimed = False

{stackops-8.102 → stackops-8.104}/src/stackops/cluster/remote/models.py

@@ -3,8 +3,8 @@ from dataclasses import dataclass, field, asdict
 from datetime import datetime, timedelta
 
 from stackops.utils.accessories import randstr
-from stackops.utils.io import read_ini
-from stackops.utils.source_of_truth import DEFAULTS_PATH
+from stackops.utils.source_of_truth import DOTFILES_STACKOPS_CONFIG_PATH, read_stackops_config_string
+from stackops.utils.schemas.config.config_types import StackOpsConfigStringKey
 
 
 JOB_STATUS: TypeAlias = Literal["queued", "running", "completed", "failed"]
@@ -158,12 +158,11 @@ class LogEntry:
         )
 
 
-def _read_default_config_value(key: str) -> str:
+def _read_default_config_value(key: StackOpsConfigStringKey) -> str:
     try:
-        section = read_ini(DEFAULTS_PATH)["general"]
-        return str(section[key])
-    except (FileNotFoundError, KeyError, IndexError) as err:
-        raise ValueError(f"Default config value '{key}' could not be read from `{DEFAULTS_PATH}`") from err
+        return read_stackops_config_string(key)
+    except (FileNotFoundError, KeyError, ValueError) as err:
+        raise ValueError(f"Config value '{key}' could not be read from `{DOTFILES_STACKOPS_CONFIG_PATH}`") from err
 
 
 @dataclass
@@ -222,9 +221,9 @@ class RemoteStackOpsConfig:
             raise ValueError("cloud_name must be provided when transfer_method is 'cloud'")
         if self.notify_upon_completion:
             if self.to_email is None:
-                self.to_email = _read_default_config_value("to_email")
+                self.to_email = _read_default_config_value("default_email_address")
             if self.email_config_name is None:
-                self.email_config_name = _read_default_config_value("email_config_name")
+                self.email_config_name = _read_default_config_value("default_email_config")
 
 
 @dataclass

stackops-8.104/src/stackops/jobs/installer/__init__.py

@@ -0,0 +1 @@
+TODO_PATH_REFERENCE = "todo.md"