stackops 26.8__tar.gz → 26.8.1__tar.gz

{stackops-26.8/src/stackops.egg-info → stackops-26.8.1}/PKG-INFO

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

{stackops-26.8 → stackops-26.8.1}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "stackops"
-version = "26.8"
+version = "26.8.1"
 description = "Developer Stack Manager"
 readme = "README.md"
 license = {text = "Apache 2.0"}
@@ -99,6 +99,7 @@ dev = [
     "numpy>=2.5.0",
     "pandas>=3.0.3",
     "paramiko>=5.0.0",
+    "playwright>=1.62.0",
     "plotly>=6.8.0",
     "polars>=1.42.0",
     "pre-commit>=4.6.0",

{stackops-26.8 → stackops-26.8.1}/src/stackops/cluster/remote/cloud_manager.py

@@ -12,9 +12,9 @@ from rich.console import Console
 
 from stackops.cluster.remote.models import JOB_STATUS, LogEntry
 from stackops.utils.cloud import rclone as rclone_utils
+from stackops.utils.cloud.default_remote import read_default_rclone_remote
 from stackops.utils.files.read import read_json
 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 = read_stackops_config_string("default_rclone_config")
+            self.cloud = read_default_rclone_remote()
         else:
             self.cloud = cloud
         self.lock_claimed = False

{stackops-26.8 → stackops-26.8.1}/src/stackops/cluster/remote/models.py

@@ -162,7 +162,12 @@ def _read_default_config_value(key: StackOpsConfigStringKey) -> str:
     try:
         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
+        setup_domain = "cloud" if key == "default_rclone_config" else "email"
+        raise ValueError(
+            f"Config value '{key}' could not be read from `{DOTFILES_STACKOPS_CONFIG_PATH}`.\n\n"
+            "Create or update it with:\n"
+            f"  devops config setup {setup_domain}"
+        ) from err
 
 
 @dataclass

{stackops-26.8 → stackops-26.8.1}/src/stackops/cluster/remote/notifications.py

@@ -3,6 +3,7 @@
 import json
 from pathlib import Path
 import smtplib
+import ssl
 import imaplib
 from email.mime.text import MIMEText
 from email.mime.multipart import MIMEMultipart
@@ -119,6 +120,9 @@ class Email:
             self.server = smtplib.SMTP_SSL(host=smtp_host, port=smtp_port)
         elif encryption_name == "tls":
             self.server = smtplib.SMTP(host=smtp_host, port=smtp_port)
+            self.server.starttls(context=ssl.create_default_context())
+        else:
+            raise ValueError(f"Email encryption for {config_name!r} must be 'tls' or 'ssl', got {encryption!r}.")
         self.server.login(self.email_add, password=password)
 
     def send_message(self, to: str, subject: str, body: str, txt_to_html: bool = True, attachments: list[Any] | None = None):

{stackops-26.8 → stackops-26.8.1}/src/stackops/jobs/installer/checks/security_cli.py

@@ -4,6 +4,8 @@ from typing import TYPE_CHECKING, Annotated, Literal
 
 import typer
 
+from stackops.jobs.installer.checks.security_helper import parse_apps_argument
+
 if TYPE_CHECKING:
     from rich.console import Console
     from rich.table import Table
@@ -20,19 +22,25 @@ def _console() -> Console:
     return Console()
 
 
-def _parse_apps_argument(apps: str | None) -> list[str] | None:
-    if apps is None:
-        return None
-    app_names = [name.strip() for name in apps.split(",") if name.strip()]
-    return app_names or None
-
-
 def _resolve_report_view(view: ReportView | None, summarize: bool) -> ReportView:
     if view is not None:
         return view
     return "app-summary" if summarize else "engines"
 
 
+def _run_scan(app_names: list[str] | None, path_value: str | None, record: bool) -> None:
+    if path_value is not None:
+        from pathlib import Path
+
+        from stackops.jobs.installer.checks.security_helper import scan_single_path
+
+        scan_single_path(Path(path_value), record)
+    else:
+        from stackops.jobs.installer.checks.check_installations import scan_installed_apps
+
+        scan_installed_apps(app_names, write_reports_to_repo=record)
+
+
 def scan(
     apps: Annotated[str | None, typer.Argument(help="Optional comma-separated app names to scan")] = None,
     path: Annotated[
@@ -50,23 +58,21 @@ def scan(
         ),
     ] = None,
 ) -> None:
-    def run_scan(apps: str | None, path: Path | None, record: bool | None) -> None:
-        from stackops.jobs.installer.checks.security_helper import scan_single_path
-
-        if apps is not None and path is not None:
-            raise typer.BadParameter("Use either APPS or --path, not both.")
-        resolved_record = record if record is not None else path is None
-        if path is not None:
-            scan_single_path(path, resolved_record)
-        else:
-            from stackops.jobs.installer.checks.check_installations import scan_installed_apps
-
-            app_names = _parse_apps_argument(apps)
-            scan_installed_apps(app_names, write_reports_to_repo=resolved_record)
+    if apps is not None and path is not None:
+        raise typer.BadParameter("Use either APPS or --path, not both.")
+    app_names = parse_apps_argument(apps)
+    path_value = str(path) if path is not None else None
+    resolved_record = record if record is not None else path is None
 
     from stackops.utils.code import run_lambda_function
 
-    run_lambda_function(lambda: run_scan(apps=apps, path=path, record=record), uv_with=["vt-py"], uv_project_dir=None)
+    proc = run_lambda_function(
+        lambda: _run_scan(app_names=app_names, path_value=path_value, record=resolved_record),
+        uv_with=["vt-py"],
+        uv_project_dir=None,
+    )
+    if proc.returncode != 0:
+        raise typer.Exit(code=proc.returncode)
 
 
 def _build_apps_table(apps_to_scan: list[tuple[Path, str | None]]) -> Table:
@@ -85,7 +91,7 @@ def _build_apps_table(apps_to_scan: list[tuple[Path, str | None]]) -> Table:
 def list_apps(apps: Annotated[str | None, typer.Argument(help="Optional comma-separated app names to list")] = None) -> None:
     from stackops.jobs.installer.checks.check_installations import collect_apps_to_scan
 
-    apps_names = _parse_apps_argument(apps)
+    apps_names = parse_apps_argument(apps)
     apps_to_scan = collect_apps_to_scan(apps_names)
     if not apps_to_scan:
         if apps_names is None:
@@ -147,7 +153,7 @@ def report(
         normalize_app_names,
     )
 
-    apps_names = _parse_apps_argument(apps)
+    apps_names = parse_apps_argument(apps)
     normalized_app_names = normalize_app_names(apps_names)
     app_rows, engine_rows, app_data_list, hydrated_engine_rows = load_filtered_report_rows(normalized_app_names)
 

stackops-26.8.1/src/stackops/jobs/installer/python_scripts/rustdesk_server.py

@@ -0,0 +1,69 @@
+import platform
+from pathlib import Path
+
+import stackops.utils.path_core as path_core
+from stackops.utils.installer_utils.installer_class import Installer
+from stackops.utils.path_core import delete_path
+from stackops.utils.schemas.installer.installer_types import InstallerData
+from stackops.utils.source_of_truth import LINUX_INSTALL_PATH, WINDOWS_INSTALL_PATH
+
+
+def _build_release_installer_data(installer_data: InstallerData) -> InstallerData:
+    release_installer_data = installer_data.copy()
+    release_installer_data["fileNamePattern"] = {
+        "amd64": {
+            "linux": "rustdesk-server-linux-amd64.zip",
+            "windows": "rustdesk-server-windows-x86_64-unsigned.zip",
+            "darwin": None,
+        },
+        "arm64": {
+            "linux": "rustdesk-server-linux-arm64v8.zip",
+            "windows": None,
+            "darwin": None,
+        },
+    }
+    return release_installer_data
+
+
+def _resolve_release_binaries(extracted_root: Path, binary_names: tuple[str, ...], suffix: str) -> dict[str, Path]:
+    resolved_binaries: dict[str, Path] = {}
+    for binary_name in binary_names:
+        expected_name = f"{binary_name}{suffix}"
+        matches = [candidate for candidate in extracted_root.rglob(expected_name) if candidate.is_file()]
+        if len(matches) != 1:
+            raise FileNotFoundError(f"Expected one {expected_name} in {extracted_root}, found {len(matches)}.")
+        resolved_binaries[binary_name] = matches[0]
+    return resolved_binaries
+
+
+def main(installer_data: InstallerData, version: str | None, update: bool) -> None:
+    _ = update
+    match platform.system():
+        case "Linux":
+            install_root = Path(LINUX_INSTALL_PATH)
+            executable_suffix = ""
+        case "Windows":
+            install_root = Path(WINDOWS_INSTALL_PATH)
+            executable_suffix = ".exe"
+        case operating_system:
+            raise NotImplementedError(f"RustDesk Server is not published for {operating_system}.")
+
+    binary_names = ("hbbs", "hbbr", "rustdesk-utils")
+    release_installer_data = _build_release_installer_data(installer_data=installer_data)
+    extracted_root, _resolved_version = Installer(installer_data=release_installer_data).binary_download(version=version)
+    _ = _resolved_version
+    try:
+        if not extracted_root.is_dir():
+            raise NotADirectoryError(f"Expected an extracted RustDesk Server archive, got {extracted_root}.")
+        resolved_binaries = _resolve_release_binaries(
+            extracted_root=extracted_root,
+            binary_names=binary_names,
+            suffix=executable_suffix,
+        )
+        install_root.mkdir(parents=True, exist_ok=True)
+        for binary_path in resolved_binaries.values():
+            if platform.system() == "Linux":
+                binary_path.chmod(0o755)
+            path_core.move(binary_path, folder=install_root, overwrite=True)
+    finally:
+        delete_path(extracted_root, verbose=False)

stackops-26.8.1/src/stackops/jobs/scripts/python_scripts/chatgpt_random_questions.py

@@ -0,0 +1,354 @@
+#!/usr/bin/env python3
+# /// script
+# requires-python = ">=3.13"
+# dependencies = [
+#   "playwright>=1.49.0",
+#   "rich>=13.9.0",
+#   "typer>=0.15.0",
+# ]
+# ///
+
+import asyncio
+import random
+import re
+import signal
+import time
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from playwright.async_api import Locator, Page, TimeoutError as PlaywrightTimeoutError, async_playwright
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import Progress, SpinnerColumn, TextColumn, TimeElapsedColumn
+from rich.table import Table
+from rich.text import Text
+
+
+DEFAULT_QUESTIONS = [
+    "What is one practical way to organize my day better?",
+    "Explain a useful idea from science in simple terms.",
+    "Give me a short writing prompt.",
+    "What is a good five-minute habit to build?",
+    "Teach me one interesting historical fact.",
+    "What is a simple recipe idea using common pantry ingredients?",
+    "Give me a small Python exercise for practice.",
+    "What is one way to improve focus while working?",
+    "Explain a common misconception in technology.",
+    "Suggest a quick mental math trick.",
+]
+
+
+app = typer.Typer(add_completion=False, help=("Send random local questions to ChatGPT through an existing logged-in Chrome/Chromium CDP session."))
+console = Console()
+
+
+class StopRequested(Exception):
+    pass
+
+
+async def find_composer(page: Page) -> Locator:
+    candidates = [
+        page.get_by_role("textbox", name=re.compile(r"(chat with chatgpt|message)", re.I)).last,
+        page.locator('[contenteditable="true"]').last,
+        page.locator("textarea").last,
+    ]
+
+    last_error: Exception | None = None
+    for candidate in candidates:
+        try:
+            await candidate.wait_for(state="visible", timeout=10_000)
+            return candidate
+        except Exception as exc:  # Playwright has several timeout subclasses.
+            last_error = exc
+
+    login_visible = await page.get_by_role("button", name=re.compile(r"log in|sign in", re.I)).count()
+    if login_visible:
+        raise RuntimeError("ChatGPT appears to be logged out. Log in in the browser, then rerun.")
+
+    raise RuntimeError(f"Could not find the ChatGPT message composer: {last_error}")
+
+
+async def extract_last_assistant_message(page: Page) -> str:
+    text = await page.evaluate(
+        """
+        () => {
+          const normalize = (value) => (value || "").replace(/\\s+\\n/g, "\\n").trim();
+
+          const roleMessages = Array.from(
+            document.querySelectorAll('[data-message-author-role="assistant"]')
+          )
+            .map((node) => normalize(node.innerText || node.textContent))
+            .filter(Boolean);
+          if (roleMessages.length) return roleMessages.at(-1);
+
+          const articles = Array.from(document.querySelectorAll("article"))
+            .map((node) => normalize(node.innerText || node.textContent))
+            .filter((value) => value && !/^you\\b/i.test(value));
+          return articles.at(-1) || "";
+        }
+        """
+    )
+    return str(text or "").strip()
+
+
+async def is_generating(page: Page) -> bool:
+    return bool(
+        await page.evaluate(
+            """
+            () => {
+              const pattern = /stop (generating|answering|streaming)|stop response/i;
+              return Array.from(document.querySelectorAll("button")).some((button) => {
+                const label = [
+                  button.innerText,
+                  button.getAttribute("aria-label"),
+                  button.getAttribute("title"),
+                ].filter(Boolean).join(" ");
+                return pattern.test(label);
+              });
+            }
+            """
+        )
+    )
+
+
+async def wait_for_response(page: Page, *, timeout_seconds: float, poll_seconds: float, stable_seconds: float) -> str:
+    deadline = time.monotonic() + timeout_seconds
+    last_text = ""
+    stable_since = time.monotonic()
+
+    while time.monotonic() < deadline:
+        text = await extract_last_assistant_message(page)
+        generating = await is_generating(page)
+
+        if text and text != last_text:
+            last_text = text
+            stable_since = time.monotonic()
+        elif text and not generating and time.monotonic() - stable_since >= stable_seconds:
+            return text
+
+        await asyncio.sleep(poll_seconds)
+
+    if last_text:
+        return last_text
+    raise TimeoutError("Timed out waiting for a ChatGPT response.")
+
+
+async def send_question(
+    *,
+    page: Page,
+    question: str,
+    chatgpt_url: str,
+    pre_submit_wait_seconds: float,
+    response_timeout_seconds: float,
+    poll_seconds: float,
+    stable_seconds: float,
+) -> str:
+    await page.goto(chatgpt_url, wait_until="domcontentloaded", timeout=60_000)
+    await page.wait_for_load_state("domcontentloaded")
+    await asyncio.sleep(pre_submit_wait_seconds)
+
+    composer = await find_composer(page)
+    await composer.click()
+    await composer.fill(question)
+    await composer.press("Enter")
+
+    return await wait_for_response(page, timeout_seconds=response_timeout_seconds, poll_seconds=poll_seconds, stable_seconds=stable_seconds)
+
+
+def load_questions(question_options: list[str] | None, questions_file: Path | None) -> list[str]:
+    questions: list[str] = []
+
+    if question_options:
+        questions.extend(q.strip() for q in question_options if q.strip())
+
+    if questions_file:
+        if not questions_file.exists():
+            raise typer.BadParameter(f"questions file does not exist: {questions_file}")
+        file_questions = [
+            line.strip() for line in questions_file.read_text(encoding="utf-8").splitlines() if line.strip() and not line.lstrip().startswith("#")
+        ]
+        questions.extend(file_questions)
+
+    return questions or list(DEFAULT_QUESTIONS)
+
+
+def print_cycle(cycle: int, question: str, response: str) -> None:
+    table = Table.grid(padding=(0, 1))
+    table.add_column(style="bold cyan", no_wrap=True)
+    table.add_column()
+    table.add_row("Cycle", str(cycle))
+    table.add_row("Question", question)
+    table.add_row("Response", response)
+    console.print(Panel(table, title="ChatGPT response", border_style="green"))
+
+
+async def sleep_with_status(seconds: float, *, cycle: int) -> None:
+    if seconds <= 0:
+        return
+
+    with Progress(
+        SpinnerColumn(), TextColumn(f"Waiting {seconds:g}s before cycle {cycle + 1}"), TimeElapsedColumn(), transient=True, console=console
+    ) as progress:
+        task = progress.add_task("sleep", total=None)
+        end = time.monotonic() + seconds
+        while time.monotonic() < end:
+            progress.update(task)
+            await asyncio.sleep(min(1.0, end - time.monotonic()))
+
+
+async def run_loop(
+    *,
+    cdp_url: str,
+    chatgpt_url: str,
+    interval_seconds: float,
+    cycles: int | None,
+    questions: list[str],
+    seed: int | None,
+    pre_submit_wait_seconds: float,
+    response_timeout_seconds: float,
+    poll_seconds: float,
+    stable_seconds: float,
+    keep_tabs: bool,
+    dry_run: bool,
+) -> None:
+    rng = random.Random(seed)
+
+    if dry_run:
+        question = rng.choice(questions)
+        console.print(Panel(question, title="Dry run question", border_style="yellow"))
+        return
+
+    stop = asyncio.Event()
+
+    def request_stop(*_: object) -> None:
+        stop.set()
+
+    loop = asyncio.get_running_loop()
+    for sig in (signal.SIGINT, signal.SIGTERM):
+        try:
+            loop.add_signal_handler(sig, request_stop)
+        except NotImplementedError:
+            pass
+
+    async with async_playwright() as playwright:
+        browser = await playwright.chromium.connect_over_cdp(cdp_url)
+        if not browser.contexts:
+            raise RuntimeError("Connected to CDP, but no browser contexts were available.")
+
+        context = browser.contexts[0]
+        cycle = 0
+
+        try:
+            while not stop.is_set():
+                cycle += 1
+                if cycles is not None and cycle > cycles:
+                    break
+
+                question = rng.choice(questions)
+                page = await context.new_page()
+
+                try:
+                    console.print(f"[bold cyan]Cycle {cycle}[/]: opening {chatgpt_url}")
+                    response = await send_question(
+                        page=page,
+                        question=question,
+                        chatgpt_url=chatgpt_url,
+                        pre_submit_wait_seconds=pre_submit_wait_seconds,
+                        response_timeout_seconds=response_timeout_seconds,
+                        poll_seconds=poll_seconds,
+                        stable_seconds=stable_seconds,
+                    )
+                    print_cycle(cycle, question, response)
+                except PlaywrightTimeoutError as exc:
+                    console.print(Panel(str(exc), title=f"Cycle {cycle} timed out", border_style="red"))
+                except Exception as exc:
+                    console.print(Panel(str(exc), title=f"Cycle {cycle} failed", border_style="red"))
+                finally:
+                    if not keep_tabs:
+                        await page.close()
+
+                if cycles is not None and cycle >= cycles:
+                    break
+
+                await sleep_with_status(interval_seconds, cycle=cycle)
+        finally:
+            # The script attaches to an existing browser over CDP. Close per-cycle tabs,
+            # but do not intentionally shut down the user's browser process on exit.
+            pass
+
+
+@app.command()
+def main(
+    cdp_url: Annotated[
+        str, typer.Option("--cdp-url", help="Chrome DevTools Protocol endpoint for the already-running browser.")
+    ] = "http://192.168.0.13:9999",
+    chatgpt_url: Annotated[str, typer.Option("--chatgpt-url", help="ChatGPT URL to open in each new tab.")] = "https://chatgpt.com/",
+    interval_minutes: Annotated[
+        float, typer.Option("--interval-minutes", "-i", min=0.0, help="Minutes to wait between cycles. Default is 10 minutes.")
+    ] = 10.0,
+    cycles: Annotated[int | None, typer.Option("--cycles", "-n", min=1, help="Number of cycles to run. Omit for infinite repeat.")] = None,
+    question: Annotated[
+        list[str] | None, typer.Option("--question", "-q", help="Question to include in the random pool. Can be passed multiple times.")
+    ] = None,
+    questions_file: Annotated[
+        Path | None,
+        typer.Option(
+            "--questions-file", "-f", exists=False, dir_okay=False, help="Newline-delimited question file. Empty lines and # comments are ignored."
+        ),
+    ] = None,
+    seed: Annotated[int | None, typer.Option("--seed", help="Random seed for reproducible question selection.")] = None,
+    pre_submit_wait_seconds: Annotated[
+        float, typer.Option("--pre-submit-wait-seconds", min=0.0, help="Seconds to wait after opening ChatGPT before typing.")
+    ] = 3.0,
+    response_timeout_seconds: Annotated[
+        float, typer.Option("--response-timeout-seconds", min=1.0, help="Maximum seconds to wait for a response per cycle.")
+    ] = 180.0,
+    poll_seconds: Annotated[float, typer.Option("--poll-seconds", min=0.25, help="How often to poll the page while waiting for the response.")] = 1.0,
+    stable_seconds: Annotated[
+        float, typer.Option("--stable-seconds", min=0.5, help="Response text must stay unchanged this long before it is considered done.")
+    ] = 2.0,
+    keep_tabs: Annotated[bool, typer.Option("--keep-tabs/--close-tabs", help="Keep each ChatGPT tab open after a cycle.")] = False,
+    dry_run: Annotated[bool, typer.Option("--dry-run", help="Pick and print a question without connecting to the browser.")] = False,
+) -> None:
+    """Open ChatGPT in a new tab, send a random question, print the response, and repeat."""
+
+    questions = load_questions(question, questions_file)
+    interval_seconds = interval_minutes * 60
+
+    summary = Table.grid(padding=(0, 1))
+    summary.add_column(style="bold")
+    summary.add_column()
+    summary.add_row("CDP URL", cdp_url)
+    summary.add_row("ChatGPT URL", chatgpt_url)
+    summary.add_row("Interval", f"{interval_minutes:g} minute(s)")
+    summary.add_row("Cycles", "infinite" if cycles is None else str(cycles))
+    summary.add_row("Question pool", str(len(questions)))
+    summary.add_row("Tabs", "keep open" if keep_tabs else "close after each cycle")
+    console.print(Panel(summary, title="Configuration", border_style="blue"))
+
+    try:
+        asyncio.run(
+            run_loop(
+                cdp_url=cdp_url,
+                chatgpt_url=chatgpt_url,
+                interval_seconds=interval_seconds,
+                cycles=cycles,
+                questions=questions,
+                seed=seed,
+                pre_submit_wait_seconds=pre_submit_wait_seconds,
+                response_timeout_seconds=response_timeout_seconds,
+                poll_seconds=poll_seconds,
+                stable_seconds=stable_seconds,
+                keep_tabs=keep_tabs,
+                dry_run=dry_run,
+            )
+        )
+    except KeyboardInterrupt:
+        console.print(Text("Stopped.", style="yellow"))
+    except StopRequested:
+        console.print(Text("Stopped.", style="yellow"))
+
+
+if __name__ == "__main__":
+    app()

{stackops-26.8 → stackops-26.8.1}/src/stackops/profile/create_links.py

@@ -6,6 +6,8 @@ This script Takes away all config files from the computer, place them in one dir
 
 from pathlib import Path
 
+import yaml
+
 from stackops.profile.linking.operations import ActionType, OperationRecord, OperationResult
 from rich.console import Console
 from rich.panel import Panel
@@ -107,7 +109,30 @@ def read_mapper(source: CONFIG_SOURCE_LOOSE) -> MapperFileData:
             return {"public": merged_public, "private": merged_private}
         case _:
             raise ValueError(f"Unsupported config source value: {source}")
-    mapper_data: MapperDocument = load_dotfiles_mapper(mapper_path)
+    if not mapper_path.exists():
+        if source_key == "user":
+            raise FileNotFoundError(
+                f"User dotfiles mapper does not exist: {mapper_path}\n\n"
+                "Create a real mapping interactively:\n"
+                "  devops config setup dotfiles\n"
+                "Or install the example and schema for manual editing:\n"
+                "  devops config dump --which dotfiles --default-path"
+            )
+        raise FileNotFoundError(f"Packaged dotfiles mapper does not exist: {mapper_path}")
+    if not mapper_path.is_file():
+        raise IsADirectoryError(f"Dotfiles mapper path is not a file: {mapper_path}")
+    try:
+        mapper_data: MapperDocument = load_dotfiles_mapper(mapper_path)
+    except (TypeError, ValueError, yaml.YAMLError) as exc:
+        if source_key == "user":
+            raise ValueError(
+                f"User dotfiles mapper is invalid: {mapper_path}\n{exc}\n\n"
+                "Open it for correction:\n"
+                "  devops config edit\n"
+                "Create a separate example and schema for reference:\n"
+                "  devops config dump --which dotfiles"
+            ) from exc
+        raise ValueError(f"Packaged dotfiles mapper is invalid: {mapper_path}\n{exc}") from exc
     public: dict[str, list[ConfigMapper]] = {}
     private: dict[str, list[ConfigMapper]] = {}
     normalized_system = _normalize_os_name(SYSTEM)

{stackops-26.8 → stackops-26.8.1}/src/stackops/profile/create_links_export.py

@@ -53,7 +53,10 @@ def main_from_parser(
         return merged_mapper
 
     source_key = CONFIG_SOURCE_MAP[source]
-    mapper_full_obj = read_mapper(source=source_key)
+    try:
+        mapper_full_obj = read_mapper(source=source_key)
+    except (OSError, TypeError, ValueError) as exc:
+        _exit_with_error(str(exc))
     mapper_full: dict[str, list[ConfigMapper]]
     sensitivity_key = SENSITIVITY_MAP[sensitivity]
     if sensitivity_key == "private":

{stackops-26.8 → stackops-26.8.1}/src/stackops/profile/dotfiles_mapper.py

@@ -15,6 +15,7 @@ LIBRARY_MAPPER_PATH = get_path_reference_path(
 )
 USER_MAPPER_PATH = DOTFILES_USER_MAPPER_PATH
 DEFAULT_DOTFILE_MAPPER_HEADER = (
+    f"# yaml-language-server: $schema=./{mapper_assets.MAPPER_DOTFILES_SCHEMA_PATH_REFERENCE}\n"
     "# User-defined config file mappings\n"
     "# Created by `d c` CLI tool\n"
     "# os must be an explicit YAML list containing one or more of: linux, darwin, windows"