Skip to content

πŸ’« Toolkit to help you get started with SDD or any other process!

feat(workflows): align workflow CLI with extension command surface (#3419)

Marsel Safind7b662621812
diff --git a/docs/reference/workflows.md b/docs/reference/workflows.md
index 16bbe0893..8bd4a8778 100644
--- a/docs/reference/workflows.md
+++ b/docs/reference/workflows.md
@@ -86,8 +86,30 @@ Lists workflows installed in the current project.
specify workflow add <source>
```
+| Option | Description |
+| --------------- | ------------------------------------------------------ |
+| `--dev` | Install from a local workflow YAML file or directory |
+| `--from <url>` | Install from a custom URL (`<source>` names the expected workflow ID) |
+
Installs a workflow from the catalog, a URL (HTTPS required), or a local file path.
+## Update Workflows
+
+```bash
+specify workflow update [workflow_id]
+```
+
+Updates one installed catalog workflow β€” or all of them when no ID is given β€” to the latest catalog version. Prompts for confirmation and keeps the installed copy if a download or validation fails.
+
+## Enable or Disable a Workflow
+
+```bash
+specify workflow enable <workflow_id>
+specify workflow disable <workflow_id>
+```
+
+Disabled workflows stay installed and listed (marked `[disabled]`) but refuse to run until re-enabled.
+
## Remove a Workflow
```bash
@@ -102,9 +124,10 @@ Removes an installed workflow from the project.
specify workflow search [query]
```
-| Option | Description |
-| ------- | --------------- |
-| `--tag` | Filter by tag |
+| Option | Description |
+| ---------- | ----------------- |
+| `--tag` | Filter by tag |
+| `--author` | Filter by author |
Searches all active catalogs for workflows matching the query.
diff --git a/src/specify_cli/_github_http.py b/src/specify_cli/_github_http.py
index 1cfb18f03..aa8223bca 100644
--- a/src/specify_cli/_github_http.py
+++ b/src/specify_cli/_github_http.py
@@ -24,6 +24,7 @@ GITHUB_HOSTS = frozenset({
"api.github.com",
"codeload.github.com",
})
+_MAX_RELEASE_METADATA_BYTES = 5 * 1024 * 1024
def build_github_request(url: str) -> urllib.request.Request:
@@ -68,6 +69,8 @@ def resolve_github_release_asset_api_url(
open_url_fn: Callable,
timeout: int = 60,
github_hosts: tuple[str, ...] = (),
+ redirect_validator: Callable[[str, str], None] | None = None,
+ max_metadata_bytes: int = _MAX_RELEASE_METADATA_BYTES,
) -> Optional[str]:
"""Resolve a GitHub release browser-download URL to its REST API asset URL.
@@ -91,6 +94,8 @@ def resolve_github_release_asset_api_url(
authenticated release-metadata lookup.
timeout: Per-request timeout in seconds.
github_hosts: Host patterns to treat as GitHub Enterprise Server.
+ redirect_validator: Optional policy applied to metadata redirects.
+ max_metadata_bytes: Maximum release-metadata response size.
"""
import json
import urllib.error
@@ -149,13 +154,33 @@ def resolve_github_release_asset_api_url(
release_url = f"{api_base}/repos/{owner}/{repo}/releases/tags/{encoded_tag}"
try:
- with open_url_fn(release_url, timeout=timeout) as response:
- release_data = json.loads(response.read())
- except (urllib.error.URLError, json.JSONDecodeError):
+ open_kwargs = {"timeout": timeout}
+ if redirect_validator is not None:
+ open_kwargs["redirect_validator"] = redirect_validator
+ with open_url_fn(release_url, **open_kwargs) as response:
+ raw_release_data = response.read(max_metadata_bytes + 1)
+ if len(raw_release_data) > max_metadata_bytes:
+ raise ValueError("GitHub release metadata exceeds size limit")
+ release_data = json.loads(raw_release_data)
+ except (
+ urllib.error.URLError,
+ json.JSONDecodeError,
+ TypeError,
+ ValueError,
+ ):
return None
- for asset in release_data.get("assets", []):
- if asset.get("name") == asset_name and asset.get("url"):
+ if not isinstance(release_data, dict):
+ return None
+ assets = release_data.get("assets", [])
+ if not isinstance(assets, list):
+ return None
+ for asset in assets:
+ if (
+ isinstance(asset, dict)
+ and asset.get("name") == asset_name
+ and asset.get("url")
+ ):
return str(asset["url"])
return None
diff --git a/src/specify_cli/bundler/lib/yamlio.py b/src/specify_cli/bundler/lib/yamlio.py
index e4cd538a0..fc9058027 100644
--- a/src/specify_cli/bundler/lib/yamlio.py
+++ b/src/specify_cli/bundler/lib/yamlio.py
@@ -10,6 +10,8 @@ from __future__ import annotations
import json
import os
import re
+import stat
+import tempfile
from pathlib import Path, PurePosixPath
from typing import Any
@@ -87,17 +89,63 @@ def loads_json(text: str, *, origin: str = "<string>") -> Any:
def dump_json(path: Path, data: Any, *, within: Path | None = None) -> Path:
- """Write *data* as pretty JSON to *path* (optionally confined to *within*)."""
+ """Atomically write pretty JSON to *path* (optionally confined to *within*)."""
path = Path(path)
if within is not None:
path = ensure_within(within, path)
+ fd = -1
+ temp_path: Path | None = None
try:
path.parent.mkdir(parents=True, exist_ok=True)
- with path.open("w", encoding="utf-8") as handle:
+ fd, temp_name = tempfile.mkstemp(
+ dir=path.parent,
+ prefix=f".{path.name}.",
+ suffix=".tmp",
+ )
+ temp_path = Path(temp_name)
+ with os.fdopen(os.dup(fd), "w", encoding="utf-8") as handle:
json.dump(data, handle, indent=2, sort_keys=False)
handle.write("\n")
+
+ try:
+ if path.exists():
+ existing = path.stat(follow_symlinks=False)
+ if stat.S_ISREG(existing.st_mode) and hasattr(os, "fchmod"):
+ os.fchmod(fd, stat.S_IMODE(existing.st_mode))
+ if stat.S_ISREG(existing.st_mode) and hasattr(os, "fchown"):
+ try:
+ os.fchown(fd, existing.st_uid, existing.st_gid)
+ except PermissionError:
+ pass
+ except OSError:
+ pass
+
+ staged = os.stat(temp_path, follow_symlinks=False)
+ opened = os.fstat(fd)
+ if (
+ not stat.S_ISREG(staged.st_mode)
+ or staged.st_dev != opened.st_dev
+ or staged.st_ino != opened.st_ino
+ ):
+ raise OSError("staged JSON file changed before commit")
+
+ os.close(fd)
+ fd = -1
+ os.replace(temp_path, path)
+ temp_path = None
except OSError as exc:
raise BundlerError(f"Could not write {path}: {exc}") from exc
+ finally:
+ if fd >= 0:
+ try:
+ os.close(fd)
+ except OSError:
+ pass
+ if temp_path is not None:
+ try:
+ temp_path.unlink(missing_ok=True)
+ except OSError:
+ pass
return path
diff --git a/src/specify_cli/bundler/services/installer.py b/src/specify_cli/bundler/services/installer.py
index 3e61ded04..7c5abf84d 100644
--- a/src/specify_cli/bundler/services/installer.py
+++ b/src/specify_cli/bundler/services/installer.py
@@ -187,19 +187,41 @@ def remove_bundle(
still_needed = components_still_needed(records, exclude_bundle_id=bundle_id)
result = InstallResult(bundle_id=bundle_id)
+ remove_attempted = False
- for component in target.contributed_components:
- key = (component.kind, component.id)
- if key in still_needed:
- result.skipped.append(component)
- continue
- if installer.is_installed(project_root, component):
- installer.remove(project_root, component)
- result.uninstalled.append(component)
+ try:
+ for component in target.contributed_components:
+ key = (component.kind, component.id)
+ if key in still_needed:
+ result.skipped.append(component)
+ continue
+ if installer.is_installed(project_root, component):
+ remove_attempted = True
+ installer.remove(project_root, component)
+ result.uninstalled.append(component)
+ save_records(project_root, remove_record(records, bundle_id))
+ except Exception as exc: # noqa: BLE001
+ if result.uninstalled:
+ detail = (
+ f"{len(result.uninstalled)} component(s) were already removed "
+ "before this failure; the bundle record was left unchanged, "
+ "so the project may be partially uninstalled."
+ )
+ elif remove_attempted:
+ detail = (
+ "No components were removed, but the failing component may "
+ "have made partial changes before raising, so the project "
+ "may be partially uninstalled."
+ )
else:
- result.skipped.append(component)
+ detail = (
+ "No components were removed and no removal was attempted; "
+ "the bundle record was left unchanged."
+ )
+ raise BundlerError(
+ f"Failed to remove bundle '{bundle_id}': {exc}. {detail}"
+ ) from exc
- save_records(project_root, remove_record(records, bundle_id))
return result
diff --git a/src/specify_cli/workflows/_commands.py b/src/specify_cli/workflows/_commands.py
index e1d29b47d..9ab199c02 100644
--- a/src/specify_cli/workflows/_commands.py
+++ b/src/specify_cli/workflows/_commands.py
@@ -58,6 +58,96 @@ def _error_console(json_output: bool):
return err_console if json_output else console
+def _open_workflow_registry(project_root: Path, out=None):
+ """Construct a WorkflowRegistry, exiting cleanly on an unreadable file.
+
+ WorkflowRegistry fails closed (raises OSError) at construction when its
+ file can't be read, rather than falling back to an empty registry a
+ caller could mistake for "nothing installed". Every CLI command that
+ opens a registry needs this same clean-error boundary.
+ """
+ from .catalog import WorkflowRegistry
+
+ try:
+ return WorkflowRegistry(project_root)
+ except OSError as exc:
+ (out or console).print(
+ f"[red]Error:[/red] Failed to read workflow registry: {_escape_markup(str(exc))}"
+ )
+ raise typer.Exit(1)
+
+
+def _require_enabled_workflow(
+ registry_root: Path, workflow_id: str, out: Any
+) -> bool:
+ """Fail closed for corrupted or explicitly disabled registry entries."""
+ metadata = _open_workflow_registry(registry_root, out).get(workflow_id)
+ if metadata is not None and not isinstance(metadata, dict):
+ out.print(
+ f"[red]Error:[/red] Registry entry for "
+ f"'{_escape_markup(workflow_id)}' is corrupted"
+ )
+ raise typer.Exit(1)
+ if isinstance(metadata, dict) and not metadata.get("enabled", True):
+ out.print(
+ f"[red]Error:[/red] Workflow '{_escape_markup(workflow_id)}' is disabled. "
+ f"Enable with: specify workflow enable {_escape_markup(workflow_id)}"
+ )
+ raise typer.Exit(1)
+ return metadata is not None
+
+
+def _path_has_symlink_component(path: Path) -> bool:
+ """Return whether any component of an absolute path is a symlink."""
+ absolute = Path(os.path.abspath(path))
+ current = Path(absolute.anchor)
+ for part in absolute.parts[1:]:
+ current /= part
+ if current.is_symlink():
+ return True
+ return False
+
+
+def _same_existing_path(left: Path, right: Path) -> bool:
+ """Return whether two existing paths identify the same filesystem entry."""
+ try:
+ return os.path.samefile(left, right)
+ except OSError:
+ return left == right
+
+
+def _resolve_run_owner_root(
+ installed_registry_root: str | None, project_root: Path
+) -> Path:
+ """Determine which project's registry gates resuming a run.
+
+ ``installed_registry_root`` is only ever persisted when the run's
+ installed workflow genuinely belongs to a *different* project than the
+ one whose ``runs/`` directory holds this run's own state (a direct
+ external workflow-file invocation) -- see ``workflow_run``. The common
+ case (an installed workflow run from its own project) stores ``None``,
+ so a later project rename/move is transparently picked up here by
+ falling back to the *current* ``project_root`` instead of a stale
+ absolute path baked in at run start.
+
+ A persisted cross-project root that no longer exists cannot be safely
+ rediscovered and must fail closed instead of consulting the unrelated
+ project that happens to store the run state.
+ """
+ if installed_registry_root:
+ candidate = Path(installed_registry_root)
+ if (
+ candidate.is_absolute()
+ and not _path_has_symlink_component(candidate)
+ and candidate.is_dir()
+ ):
+ return candidate
+ raise ValueError(
+ "Installed workflow owner is unavailable; cannot safely resume"
+ )
+ return project_root
+
+
def _parse_input_values(
input_values: list[str] | None, *, json_output: bool = False
) -> dict[str, Any]:
@@ -104,15 +194,266 @@ def _reject_unsafe_workflow_storage(project_root: Path) -> None:
)
+def _scan_for_workflow_owner(parts: tuple[str, ...]) -> int | None:
+ """Find the *nearest* (innermost) ``.specify/workflows/<id>`` owner in
+ *parts*, scanning from the end of the path.
+
+ Scanning from the end (rather than stopping at the first match from the
+ start) matters for a project nested beneath an unrelated outer path that
+ happens to reuse the same ``.specify``/``workflows`` segment names: the
+ first-from-start match would pick the outer directory and the wrong
+ workflow ID, silently missing the real (inner) owner's disabled check.
+
+ Returns the index of the owning ``.specify`` segment, or ``None`` if no
+ owner segment is present.
+ """
+ for i in range(len(parts) - 3, -1, -1):
+ if (
+ parts[i].casefold() == ".specify"
+ and parts[i + 1].casefold() == "workflows"
+ ):
+ return i
+ return None
+
+
+def _expand_first_symlink_target(path: Path) -> Path | None:
+ """Expand one symlink component while preserving the remaining path."""
+ parts = path.parts
+ current = Path(path.anchor) if path.is_absolute() else Path()
+ start = 1 if path.is_absolute() else 0
+ for index in range(start, len(parts)):
+ current = current / parts[index]
+ if not current.is_symlink():
+ continue
+ try:
+ target = Path(os.readlink(current))
+ except OSError:
+ return None
+ if not target.is_absolute():
+ target = current.parent / target
+ expanded = target.joinpath(*parts[index + 1 :])
+ return Path(os.path.normpath(str(expanded.absolute())))
+ return None
+
+
+def _resolve_installed_workflow_ownership(
+ source_path: Path, err
+) -> tuple[Path | None, str | None]:
+ """Map a direct ``workflow.yml`` *source_path* back to the installed
+ workflow (``registry_root``, ``registered_id``) it belongs to, if any.
+
+ A registered path can point at installed storage three ways, all of
+ which must receive the same registry disabled-check:
+
+ 1. Lexically: the path's own (symlink-preserving) segments identify
+ ``.specify/workflows/<id>`` -- collapsing ``..``/``.`` but
+ never resolving symlinks, so a symlinked ``workflow.yml`` leaf (or
+ symlinked ``<id>`` directory) inside the owned tree is caught by the
+ inward-symlink refusal below rather than silently followed.
+ 2. Via an intermediate alias target whose lexical path identifies
+ ``.specify/workflows/<id>`` before a symlinked storage ancestor is
+ resolved away.
+ 3. Via an outward-pointing alias whose fully resolved target lands
+ inside legitimate installed storage, even though the raw invocation
+ path has no ownership segments.
+
+ Returns ``(None, None)`` when neither applies -- a genuinely standalone
+ external workflow file, which is allowed to run unchecked.
+ """
+ def ownership_for(candidate: Path) -> tuple[Path, str] | None:
+ parts = candidate.parts
+ i = _scan_for_workflow_owner(parts)
+ if i is None:
+ return None
+ registry_root = (
+ Path(*parts[:i]) if i else Path(candidate.anchor or ".")
+ )
+ candidate_specify = Path(*parts[: i + 1])
+ candidate_workflows = Path(*parts[: i + 2])
+ candidate_id_dir = Path(*parts[: i + 3])
+ canonical_specify = registry_root / ".specify"
+ canonical_workflows = canonical_specify / "workflows"
+ # The path-derived registry_root here may differ from the cwd's
+ # project_root already checked by _reject_unsafe_workflow_storage
+ # (e.g. this path points into another project entirely, or this
+ # project's own .specify is itself a symlink to an
+ # attacker-controlled tree) -- check it explicitly rather than
+ # trusting that cwd-scoped guard, and don't rely on
+ # WorkflowRegistry's own symlinked-parent handling as the safety
+ # signal here: it fails closed by raising OSError at construction
+ # time (see catalog.py's _load), but that surfaces as an opaque
+ # exception rather than this guard's clean, specific CLI error for
+ # the actual owning project root.
+ _reject_unsafe_dir(canonical_specify, ".specify")
+ _reject_unsafe_dir(canonical_workflows, ".specify/workflows")
+ _reject_unsafe_dir(candidate_specify, ".specify")
+ _reject_unsafe_dir(candidate_workflows, ".specify/workflows")
+ try:
+ if not os.path.samefile(candidate_specify, canonical_specify):
+ return None
+ if not os.path.samefile(
+ candidate_workflows, canonical_workflows
+ ):
+ return None
+ except OSError:
+ return None
+ registry = _open_workflow_registry(registry_root, err)
+ registered_id = None
+ for workflow_id in registry.list():
+ if (
+ not isinstance(workflow_id, str)
+ or workflow_id in _RESERVED_WORKFLOW_IDS
+ or not _WORKFLOW_ID_PATTERN.fullmatch(workflow_id)
+ ):
+ continue
+ try:
+ if os.path.samefile(
+ candidate_id_dir,
+ canonical_workflows / workflow_id,
+ ):
+ registered_id = workflow_id
+ break
+ except OSError:
+ continue
+ if registered_id is None:
+ return None
+ # A legitimately installed workflow's own directory tree never
+ # contains a symlink (workflow add/remove both refuse one at
+ # install time); one appearing here means the file actually loaded
+ # below would not be the file this ownership match is based on, so
+ # refuse rather than silently mismatch.
+ for k in range(i + 2, len(parts) + 1):
+ if Path(*parts[:k]).is_symlink():
+ err.print(
+ "[red]Error:[/red] Refusing to run: "
+ f".specify/workflows/{_escape_markup(registered_id)} "
+ "contains a symlinked path component"
+ )
+ raise typer.Exit(1)
+ return registry_root, registered_id
+
+ lexical = Path(os.path.normpath(str(source_path.absolute())))
+ ownership = ownership_for(lexical)
+ if ownership is not None:
+ return ownership
+
+ # Inspect each intermediate symlink target before fully resolving it.
+ # Full resolution can erase .specify/workflows ownership segments when
+ # one of those storage directories is itself a symlink.
+ candidate = lexical
+ seen = {candidate}
+ for _ in range(40):
+ expanded = _expand_first_symlink_target(candidate)
+ if expanded is None or expanded in seen:
+ break
+ ownership = ownership_for(expanded)
+ if ownership is not None:
+ return ownership
+ seen.add(expanded)
+ candidate = expanded
+
+ # A fully resolved target may still land in legitimate installed
+ # storage through an unrelated-looking alias.
+ try:
+ resolved = source_path.resolve(strict=False)
+ except (OSError, RuntimeError):
+ return None, None
+ if resolved == lexical:
+ # Nothing on this path is a symlink; already covered above.
+ return None, None
+ ownership = ownership_for(resolved)
+ return ownership if ownership is not None else (None, None)
+
+
_WORKFLOW_ID_PATTERN = re.compile(r"^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$")
_RESERVED_WORKFLOW_IDS: frozenset[str] = frozenset({"runs", "steps"})
+def _reject_insecure_download_redirect(old_url: str, new_url: str) -> None:
+ """Reject insecure redirects before they are followed."""
+ import urllib.error
+ from ipaddress import ip_address
+ from urllib.parse import urlparse
+
+ def _is_loopback_http(url: str) -> bool:
+ parsed = urlparse(url)
+ if parsed.scheme != "http":
+ return False
+ host = parsed.hostname or ""
+ if host == "localhost":
+ return True
+ try:
+ return ip_address(host).is_loopback
+ except ValueError:
+ return False
+
+ if urlparse(new_url).scheme == "https":
+ return
+ if _is_loopback_http(old_url) and _is_loopback_http(new_url):
+ return
+ raise urllib.error.URLError(
+ "redirect target must use HTTPS; loopback HTTP may only redirect from loopback HTTP"
+ )
+
+
+# Workflow YAML definitions are small step/metadata text, not binaries, so
+# this is generous headroom against a malicious or misbehaving server -- not
+# a ceiling any legitimate workflow definition should ever approach.
+_MAX_WORKFLOW_YAML_BYTES = 5 * 1024 * 1024 # 5 MiB
+_DOWNLOAD_CHUNK_SIZE = 65536
+
+
+def _read_response_within_limit(response, max_bytes: int | None = None) -> bytes:
+ """Read *response* fully, enforcing *max_bytes* via bounded streaming.
+
+ A ``Content-Length`` header is checked up front to fail fast, but it is
+ never trusted alone: the actual bytes read are also counted as they
+ stream in, so a chunked or ``Content-Length``-less response that lies
+ about (or omits) its size still cannot exceed the limit.
+
+ ``max_bytes`` defaults to ``None`` (resolved to the module-level
+ ``_MAX_WORKFLOW_YAML_BYTES`` at call time, not at function-definition
+ time) so tests can override the effective limit via monkeypatching the
+ module attribute.
+ """
+ if max_bytes is None:
+ max_bytes = _MAX_WORKFLOW_YAML_BYTES
+ content_length = None
+ getheader = getattr(response, "getheader", None)
+ if callable(getheader):
+ try:
+ raw_length = getheader("Content-Length")
+ except Exception:
+ raw_length = None
+ if raw_length is not None:
+ try:
+ content_length = int(raw_length)
+ except (TypeError, ValueError):
+ content_length = None
+ if content_length is not None and content_length > max_bytes:
+ raise ValueError(
+ f"response declared {content_length} bytes, exceeding the "
+ f"{max_bytes}-byte workflow size limit"
+ )
+
+ chunks: list[bytes] = []
+ total = 0
+ while True:
+ chunk = response.read(_DOWNLOAD_CHUNK_SIZE)
+ if not chunk:
+ break
+ total += len(chunk)
+ if total > max_bytes:
+ raise ValueError(f"response exceeds the {max_bytes}-byte workflow size limit")
+ chunks.append(chunk)
+ return b"".join(chunks)
+
+
def _validate_workflow_id_or_exit(workflow_id: str) -> None:
"""Validate that ``workflow_id`` is a safe installed-workflow directory name."""
if (
workflow_id in _RESERVED_WORKFLOW_IDS
- or not _WORKFLOW_ID_PATTERN.match(workflow_id)
+ or not _WORKFLOW_ID_PATTERN.fullmatch(workflow_id)
):
console.print(
f"[red]Error:[/red] Invalid workflow ID: {_escape_markup(repr(workflow_id))}"
@@ -170,6 +511,368 @@ def _safe_workflow_id_dir(workflows_dir: Path, workflow_id: str) -> Path:
return dest_dir
+class _StagedWorkflowFile:
+ """Exclusive staging inode kept open until its atomic commit."""
+
+ def __init__(self, path: Path, fd: int) -> None:
+ self.path = path
+ self.fd = fd
+
+ def _write(self, chunks) -> None:
+ os.lseek(self.fd, 0, os.SEEK_SET)
+ os.ftruncate(self.fd, 0)
+ for chunk in chunks:
+ view = memoryview(chunk)
+ while view:
+ written = os.write(self.fd, view)
+ if written <= 0:
+ raise OSError("Failed to write staged workflow file")
+ view = view[written:]
+
+ def write_bytes(self, data: bytes) -> None:
+ self._write((data,))
+
+ def verify_path(self) -> None:
+ import stat
+
+ try:
+ path_stat = self.path.stat(follow_symlinks=False)
+ open_stat = os.fstat(self.fd)
+ except OSError as exc:
+ raise OSError(
+ "Staged workflow file changed before commit"
+ ) from exc
+ if (
+ not stat.S_ISREG(path_stat.st_mode)
+ or path_stat.st_dev != open_stat.st_dev
+ or path_stat.st_ino != open_stat.st_ino
+ ):
+ raise OSError("Staged workflow file changed before commit")
+
+ def set_mode(self, mode: int) -> None:
+ if hasattr(os, "fchmod"):
+ os.fchmod(self.fd, mode)
+
+ def close(self) -> None:
+ if self.fd < 0:
+ return
+ fd, self.fd = self.fd, -1
+ try:
+ os.close(fd)
+ except OSError:
+ pass
+
+
+def _stage_workflow_file(
+ dest_dir: Path, *, use_project_file_mode: bool = False
+) -> _StagedWorkflowFile:
+ """Reserve a same-directory staging file so new/updated workflow.yml
+ content can be written and validated without ever touching (and risking
+ truncating) an existing destination file before the final atomic swap.
+ Shared by the local-install and catalog-install paths.
+
+ If dest_dir did not already exist, this call creates it; if mkstemp then
+ fails (disk full/EMFILE/quota), the freshly-created directory is removed
+ again via a guarded rmdir (never a broad rmtree, so any concurrently
+ written content is left untouched) before the original OSError is
+ re-raised unchanged. A pre-existing dest_dir (reinstall) is never
+ touched by this cleanup. For catalog-created files,
+ ``use_project_file_mode`` recreates the reserved path exclusively with
+ mode 0666 so the process umask supplies the normal project-file mode.
+ The final descriptor remains open so callers write to and verify the
+ reserved inode rather than reopening a replaceable pathname."""
+ import tempfile
+
+ created_dir = not dest_dir.exists()
+ dest_dir.mkdir(parents=True, exist_ok=True)
+ fd = -1
+ staged_file: Path | None = None
+ try:
+ fd, tmp_name = tempfile.mkstemp(dir=dest_dir, prefix=".workflow.yml.", suffix=".tmp")
+ staged_file = Path(tmp_name)
+ if use_project_file_mode:
+ os.close(fd)
+ fd = -1
+ staged_file.unlink()
+ flags = os.O_RDWR | os.O_CREAT | os.O_EXCL
+ flags |= getattr(os, "O_NOFOLLOW", 0)
+ fd = os.open(staged_file, flags, 0o666)
+ except OSError:
+ if fd >= 0:
+ try:
+ os.close(fd)
+ except OSError:
+ pass
+ if staged_file is not None:
+ try:
+ staged_file.unlink(missing_ok=True)
+ except OSError:
+ pass
+ if created_dir:
+ try:
+ dest_dir.rmdir()
+ except OSError as cleanup_exc:
+ console.print(
+ "[yellow]Warning:[/yellow] Failed to remove incomplete "
+ f"workflow directory: {_escape_markup(str(cleanup_exc))}"
+ )
+ raise
+ assert staged_file is not None
+ return _StagedWorkflowFile(staged_file, fd)
+
+
+def _workflow_install_transaction(project_root: Path):
+ """Serialize workflow file swaps with their registry updates."""
+ from ..shared_infra import _ensure_safe_shared_directory
+
+ lock_dir = project_root / ".specify"
+ try:
+ _ensure_safe_shared_directory(
+ project_root, lock_dir, context="workflow install lock directory"
+ )
+ except ValueError as exc:
+ raise OSError(str(exc)) from exc
+ lock_file = lock_dir / ".workflow-install.lock"
+ if lock_file.is_symlink():
+ raise OSError(f"Refusing to use symlinked workflow install lock: {lock_file}")
+
+ flags = os.O_RDWR | os.O_CREAT
+ flags |= getattr(os, "O_NOFOLLOW", 0)
+ flags |= getattr(os, "O_CLOEXEC", 0)
+ fd = os.open(lock_file, flags, 0o600)
+ try:
+ if lock_file.is_symlink():
+ raise OSError(
+ f"Refusing to use symlinked workflow install lock: {lock_file}"
+ )
+ if os.name == "nt":
+ import errno
+ import msvcrt
+ import time
+
+ if os.fstat(fd).st_size == 0:
+ os.write(fd, b"\0")
+ while True:
+ os.lseek(fd, 0, os.SEEK_SET)
+ try:
+ msvcrt.locking(fd, msvcrt.LK_NBLCK, 1)
+ break
+ except OSError as exc:
+ if exc.errno not in (errno.EACCES, errno.EDEADLK):
+ raise
+ time.sleep(0.05)
+ else:
+ import fcntl
+
+ fcntl.flock(fd, fcntl.LOCK_EX)
+ yield
+ finally:
+ os.close(fd)
+
+
+def _commit_workflow_file(
+ staged_file: Path | _StagedWorkflowFile,
+ dest_file: Path,
+ existed_before: bool,
+) -> Path | None:
+ """Atomically swap ``staged_file`` onto ``dest_file``. If a prior file
+ existed, it is first renamed to a unique sibling (path returned) so a
+ later failure (e.g. registry.add()) can restore it via rename instead
+ of a content rewrite -- the destination is never truncated/overwritten
+ in place. If the second rename fails after the first succeeded, the
+ prior file is put back immediately so dest_file is never left simply
+ missing."""
+ staged_path = (
+ staged_file.path
+ if isinstance(staged_file, _StagedWorkflowFile)
+ else staged_file
+ )
+ if isinstance(staged_file, _StagedWorkflowFile):
+ staged_file.verify_path()
+ if existed_before and dest_file.exists():
+ import tempfile
+
+ dest_state = dest_file.stat(follow_symlinks=False)
+ mode = dest_state.st_mode & 0o7777
+ if isinstance(staged_file, _StagedWorkflowFile):
+ staged_file.set_mode(mode)
+ else:
+ staged_path.chmod(mode)
+ fd, backup_name = tempfile.mkstemp(
+ dir=dest_file.parent,
+ prefix=f".{dest_file.name}.",
+ suffix=".bak",
+ )
+ try:
+ placeholder_state = os.fstat(fd)
+ finally:
+ os.close(fd)
+ backup_file = Path(backup_name)
+ try:
+ os.replace(dest_file, backup_file)
+ except BaseException as move_exc:
+ backup_state = None
+ try:
+ backup_state = backup_file.stat(follow_symlinks=False)
+ except OSError:
+ pass
+ if (
+ backup_state is not None
+ and os.path.samestat(dest_state, backup_state)
+ ):
+ try:
+ os.replace(backup_file, dest_file)
+ except OSError as restore_exc:
+ raise OSError(
+ f"Failed to stage prior workflow ({move_exc}); failed "
+ f"to restore it from {backup_file} ({restore_exc}). "
+ f"The prior workflow remains at {backup_file}."
+ ) from restore_exc
+ elif (
+ backup_state is not None
+ and os.path.samestat(placeholder_state, backup_state)
+ ):
+ try:
+ backup_file.unlink(missing_ok=True)
+ except OSError:
+ pass
+ raise
+ try:
+ if isinstance(staged_file, _StagedWorkflowFile):
+ staged_file.verify_path()
+ # Windows cannot replace an open file. Verify through the
+ # exclusive descriptor, then close immediately before rename.
+ staged_file.close()
+ os.replace(staged_path, dest_file)
+ except BaseException as commit_exc:
+ try:
+ os.replace(backup_file, dest_file)
+ except OSError as restore_exc:
+ raise OSError(
+ f"Failed to commit workflow file ({commit_exc}); failed "
+ f"to restore the prior workflow from {backup_file} "
+ f"({restore_exc}). The prior workflow remains at "
+ f"{backup_file}."
+ ) from restore_exc
+ raise
+ return backup_file
+ if isinstance(staged_file, _StagedWorkflowFile):
+ staged_file.verify_path()
+ staged_file.close()
+ os.replace(staged_path, dest_file)
+ return None
+
+
+def _discard_staged_workflow_file(
+ staged_file: Path | _StagedWorkflowFile,
+ dest_dir: Path,
+ existed_before: bool,
+) -> None:
+ """Clean up after a pre-commit failure (staged_file was never swapped
+ onto dest_file): remove the staged file, and for a fresh install (no
+ prior directory) remove the now-orphaned dest_dir too. A genuine
+ removal failure must propagate (not be swallowed) so the safe wrapper
+ below can warn instead of silently leaving an orphan; a dest_dir
+ already absent is not itself an error."""
+ staged_path = (
+ staged_file.path
+ if isinstance(staged_file, _StagedWorkflowFile)
+ else staged_file
+ )
+ if isinstance(staged_file, _StagedWorkflowFile):
+ staged_file.close()
+ staged_path.unlink(missing_ok=True)
+ if not existed_before and dest_dir.exists():
+ import errno
+
+ try:
+ dest_dir.rmdir()
+ except OSError as exc:
+ # Another concurrent install may already have committed content
+ # into this once-fresh directory. Never recursively delete it.
+ if exc.errno not in (errno.ENOTEMPTY, errno.EEXIST):
+ raise
+
+
+def _rollback_committed_workflow_file(
+ dest_file: Path, dest_dir: Path, existed_before: bool, backup_file: Path | None
+) -> None:
+ """Undo a successful _commit_workflow_file swap after a later failure
+ (registry.add()): restore the prior file via rename, remove the newly
+ committed file for a reinstall over a pre-existing empty directory
+ (no backup), or remove the new file and then its directory when empty
+ for a fresh install. A genuine removal failure must propagate (not be
+ swallowed) so the safe wrapper below can warn instead of silently
+ leaving an orphan; a dest_dir already absent is not itself an error."""
+ if backup_file is not None:
+ os.replace(backup_file, dest_file)
+ else:
+ dest_file.unlink(missing_ok=True)
+ if not existed_before and dest_dir.exists():
+ import errno
+
+ try:
+ dest_dir.rmdir()
+ except OSError as exc:
+ # Another installer may have staged a sibling before taking
+ # the transaction lock. Preserve it rather than recursively
+ # deleting the shared directory during this rollback.
+ if exc.errno not in (errno.ENOTEMPTY, errno.EEXIST):
+ raise
+
+
+def _safe_discard_staged_workflow_file(
+ staged_file: Path | _StagedWorkflowFile,
+ dest_dir: Path,
+ existed_before: bool,
+) -> None:
+ """Guarded wrapper: a cleanup failure must be reported, never crash or
+ silently mask the original install error that triggered it."""
+ try:
+ _discard_staged_workflow_file(staged_file, dest_dir, existed_before)
+ except OSError as exc:
+ console.print(
+ "[yellow]Warning:[/yellow] Failed to clean up incomplete workflow "
+ f"install: {_escape_markup(str(exc))}"
+ )
+
+
+def _safe_rollback_committed_workflow_file(
+ dest_file: Path, dest_dir: Path, existed_before: bool, backup_file: Path | None
+) -> None:
+ """Guarded wrapper: a rollback failure must be reported, never crash or
+ silently claim the prior workflow file was restored when it wasn't."""
+ try:
+ _rollback_committed_workflow_file(dest_file, dest_dir, existed_before, backup_file)
+ except OSError as exc:
+ console.print(
+ "[yellow]Warning:[/yellow] Failed to restore prior workflow file "
+ f"after registry update failure: {_escape_markup(str(exc))}"
+ )
+
+
+def _discard_committed_backup_file(backup_file: Path | None) -> None:
+ """Once registry.add()/registry.remove() has durably succeeded after a
+ _commit_workflow_file() swap, the renamed-aside prior file is no longer
+ needed for rollback -- it must be discarded, not left as a permanent
+ orphan sibling that every future reinstall would silently accumulate or
+ clobber. A cleanup failure here must not turn an already-successful
+ install into a reported failure; it's reported as a warning, consistent
+ with workflow_remove's post-commit cleanup semantics. A fresh install
+ (backup_file is None) is a no-op."""
+ if backup_file is None:
+ return
+ try:
+ backup_file.unlink(missing_ok=True)
+ except OSError as exc:
+ console.print(
+ "[yellow]Warning:[/yellow] Workflow installed, but its backup file "
+ f"could not be cleaned up: {_escape_markup(str(exc))}. Remove it "
+ f"manually: {_escape_markup(str(backup_file))}"
+ )
+
+
# Root helper re-fetched at call time so test monkeypatching of
# `specify_cli._require_specify_project` keeps working after the move.
def _require_specify_project(*args, **kwargs):
@@ -348,6 +1051,32 @@ def workflow_run(
engine.on_step_start = lambda sid, label: console.print(f" \u25b8 [{sid}] {label} \u2026")
err = _error_console(json_output)
+
+ registered_id: str | None = None
+ registry_root = project_root
+ if not is_file_source:
+ # Reject path-equivalent spellings ("align-wf/", "align-wf/.") that
+ # would miss the registry lookup yet still load the installed file,
+ # bypassing the disabled check below.
+ if source in _RESERVED_WORKFLOW_IDS or not _WORKFLOW_ID_PATTERN.fullmatch(source):
+ err.print(
+ f"[red]Error:[/red] Invalid workflow ID: {_escape_markup(repr(source))}"
+ )
+ raise typer.Exit(1)
+ registered_id = source
+ else:
+ # A direct YAML path may still point at an installed workflow's own
+ # file (lexically, or via a symlinked alias pointing into installed
+ # storage); map it back to its owning project and ID so the
+ # disabled check below can't be silently bypassed.
+ owner_root, owner_id = _resolve_installed_workflow_ownership(source_path, err)
+ if owner_id is not None:
+ registry_root = owner_root
+ registered_id = owner_id
+
+ if registered_id is not None:
+ _require_enabled_workflow(registry_root, registered_id, err)
+
try:
definition = engine.load_workflow(source_path if is_file_source else source)
except FileNotFoundError:
@@ -362,7 +1091,7 @@ def workflow_run(
if errors:
err.print("[red]Workflow validation failed:[/red]")
for verr in errors:
- err.print(f" β€’ {verr}")
+ err.print(f" β€’ {_escape_markup(str(verr))}")
raise typer.Exit(1)
# Parse inputs
@@ -374,7 +1103,26 @@ def workflow_run(
try:
with _stdout_to_stderr_when(json_output):
- state = engine.execute(definition, inputs)
+ state = engine.execute(
+ definition,
+ inputs,
+ installed_workflow_id=registered_id,
+ # Only persist an explicit root when the installed workflow
+ # genuinely belongs to a *different* project than the one
+ # whose runs/ directory holds this run's own state (a
+ # direct external workflow-file invocation) -- the common
+ # case (an installed workflow run from its own project)
+ # leaves this None so resume re-derives the owning root
+ # from wherever the project currently is, transparently
+ # surviving a project rename/move instead of baking in a
+ # stale absolute path at run start.
+ installed_registry_root=(
+ registry_root.resolve(strict=True)
+ if registered_id
+ and not _same_existing_path(registry_root, project_root)
+ else None
+ ),
+ )
except ValueError as exc:
err.print(f"[red]Error:[/red] {exc}")
raise typer.Exit(1)
@@ -416,7 +1164,7 @@ def workflow_resume(
):
"""Resume a paused or failed workflow run."""
from . import load_custom_steps
- from .engine import WorkflowEngine
+ from .engine import RunState, WorkflowEngine
project_root = _require_specify_project()
load_custom_steps(project_root)
@@ -427,6 +1175,48 @@ def workflow_resume(
inputs = _parse_input_values(input_values, json_output=json_output)
err = _error_console(json_output)
+ # Pre-load the persisted run state so a run started from an installed
+ # workflow that has since been disabled cannot resume unchecked --
+ # engine.resume() replays the run directly from disk with no registry
+ # awareness at all, which would otherwise bypass the same disabled
+ # guard `workflow run` enforces. Runs without installed_workflow_id
+ # (a direct/non-installed source, or a run persisted before this field
+ # existed) are unaffected and resume exactly as before.
+ try:
+ pre_state = RunState.load(run_id, project_root)
+ except FileNotFoundError:
+ err.print(f"[red]Error:[/red] Run not found: {run_id}")
+ raise typer.Exit(1)
+ except ValueError as exc:
+ err.print(f"[red]Error:[/red] {_escape_markup(str(exc))}")
+ raise typer.Exit(1)
+ except OSError as exc:
+ err.print(f"[red]Resume failed:[/red] {_escape_markup(str(exc))}")
+ raise typer.Exit(1)
+
+ if pre_state.installed_workflow_id is not None:
+ try:
+ owner_root = _resolve_run_owner_root(
+ pre_state.installed_registry_root, project_root
+ )
+ except ValueError as exc:
+ err.print(f"[red]Error:[/red] {_escape_markup(str(exc))}")
+ raise typer.Exit(1)
+ _require_enabled_workflow(
+ owner_root, pre_state.installed_workflow_id, err
+ )
+ elif not pre_state.installed_origin_tracked:
+ if _require_enabled_workflow(
+ project_root, pre_state.workflow_id, err
+ ):
+ pre_state.installed_workflow_id = pre_state.workflow_id
+ pre_state.installed_origin_tracked = True
+ try:
+ pre_state.save()
+ except OSError as exc:
+ err.print(f"[red]Resume failed:[/red] {_escape_markup(str(exc))}")
+ raise typer.Exit(1)
+
try:
with _stdout_to_stderr_when(json_output):
state = engine.resume(run_id, inputs or None)
@@ -434,10 +1224,10 @@ def workflow_resume(
err.print(f"[red]Error:[/red] Run not found: {run_id}")
raise typer.Exit(1)
except ValueError as exc:
- err.print(f"[red]Error:[/red] {exc}")
+ err.print(f"[red]Error:[/red] {_escape_markup(str(exc))}")
raise typer.Exit(1)
except Exception as exc:
- err.print(f"[red]Resume failed:[/red] {exc}")
+ err.print(f"[red]Resume failed:[/red] {_escape_markup(str(exc))}")
raise typer.Exit(1)
if json_output:
@@ -478,6 +1268,9 @@ def workflow_status(
except FileNotFoundError:
console.print(f"[red]Error:[/red] Run not found: {run_id}")
raise typer.Exit(1)
+ except ValueError as exc:
+ console.print(f"[red]Error:[/red] {_escape_markup(str(exc))}")
+ raise typer.Exit(1)
if json_output:
# Build on the shared run/resume payload so the common fields
@@ -556,10 +1349,8 @@ def workflow_status(
@workflow_app.command("list")
def workflow_list():
"""List installed workflows."""
- from .catalog import WorkflowRegistry
-
project_root = _require_specify_project()
- registry = WorkflowRegistry(project_root)
+ registry = _open_workflow_registry(project_root)
installed = registry.list()
if not installed:
@@ -570,36 +1361,61 @@ def workflow_list():
console.print("\n[bold cyan]Installed Workflows:[/bold cyan]\n")
for wf_id, wf_data in installed.items():
- console.print(f" [bold]{wf_data.get('name', wf_id)}[/bold] ({wf_id}) v{wf_data.get('version', '?')}")
+ safe_id = _escape_markup(wf_id)
+ if not isinstance(wf_data, dict):
+ console.print(f" [yellow]Warning:[/yellow] Skipping corrupted registry entry '{safe_id}'.\n")
+ continue
+ marker = "" if wf_data.get("enabled", True) else " [red]\\[disabled][/red]"
+ name = _escape_markup(str(wf_data.get("name", wf_id)))
+ version = _escape_markup(str(wf_data.get("version", "?")))
+ console.print(f" [bold]{name}[/bold] ({safe_id}) v{version}{marker}")
desc = wf_data.get("description", "")
if desc:
- console.print(f" {desc}")
+ console.print(f" {_escape_markup(str(desc))}")
console.print()
@workflow_app.command("add")
def workflow_add(
source: str = typer.Argument(..., help="Workflow ID, URL, or local path"),
+ dev: bool = typer.Option(False, "--dev", help="Install from a local workflow YAML file or directory"),
+ from_url: str | None = typer.Option(None, "--from", help="Install from a custom URL"),
):
"""Install a workflow from catalog, URL, or local path."""
- from .catalog import WorkflowCatalog, WorkflowRegistry, WorkflowCatalogError
from .engine import WorkflowDefinition
project_root = _require_specify_project()
- registry = WorkflowRegistry(project_root)
+ _open_workflow_registry(project_root)
workflows_dir = project_root / ".specify" / "workflows"
+ # With --from, source names the expected workflow ID: validate it up
+ # front so a URL/path/typo fails without a network fetch.
+ if from_url is not None and not dev:
+ _validate_workflow_id_or_exit(source)
# Reject a symlinked .specify / .specify/workflows before any write so an
# install can't escape the project root (covers the local, URL, and
# catalog branches below β€” all write beneath workflows_dir).
_reject_unsafe_dir(project_root / ".specify", ".specify")
_reject_unsafe_dir(workflows_dir, ".specify/workflows")
- def _validate_and_install_local(yaml_path: Path, source_label: str) -> None:
+ def _validate_and_install_local(
+ yaml_path: Path, source_label: str, expected_id: str | None = None
+ ) -> None:
"""Validate and install a workflow from a local YAML file."""
try:
- definition = WorkflowDefinition.from_yaml(yaml_path)
- except (ValueError, yaml.YAMLError) as exc:
- console.print(f"[red]Error:[/red] Invalid workflow YAML: {exc}")
+ with yaml_path.open("rb") as source_file:
+ source_mode = os.fstat(source_file.fileno()).st_mode & 0o7777
+ source_content = source_file.read()
+ definition = WorkflowDefinition.from_string(
+ source_content.decode("utf-8")
+ )
+ except OSError as exc:
+ console.print(
+ f"[red]Error:[/red] Failed to read workflow YAML: "
+ f"{_escape_markup(str(exc))}"
+ )
+ raise typer.Exit(1)
+ except (UnicodeDecodeError, ValueError, yaml.YAMLError) as exc:
+ console.print(f"[red]Error:[/red] Invalid workflow YAML: {_escape_markup(str(exc))}")
raise typer.Exit(1)
# Non-string ids (e.g. unquoted ``id: 123`` or ``id: 0``) fall through
# to validate_workflow below, which reports a typed error instead of
@@ -618,31 +1434,144 @@ def workflow_add(
if errors:
console.print("[red]Error:[/red] Workflow validation failed:")
for err in errors:
- console.print(f" \u2022 {err}")
+ console.print(f" \u2022 {_escape_markup(str(err))}")
+ raise typer.Exit(1)
+
+ if expected_id is not None and definition.id != expected_id:
+ console.print(
+ f"[red]Error:[/red] Workflow ID in YAML ({_escape_markup(repr(definition.id))}) "
+ f"does not match the requested workflow ID ({_escape_markup(repr(expected_id))})."
+ )
raise typer.Exit(1)
dest_dir = _safe_workflow_id_dir(workflows_dir, definition.id)
- dest_dir.mkdir(parents=True, exist_ok=True)
- import shutil
- shutil.copy2(yaml_path, dest_dir / "workflow.yml")
- registry.add(definition.id, {
- "name": definition.name,
- "version": definition.version,
- "description": definition.description,
- "source": source_label,
- })
- console.print(f"[green]βœ“[/green] Workflow '{definition.name}' ({definition.id}) installed")
-
- # Try as URL (http/https)
- if source.startswith("http://") or source.startswith("https://"):
+ dest_file = dest_dir / "workflow.yml"
+ existed_before = dest_dir.is_dir()
+
+ try:
+ staged_file = _stage_workflow_file(dest_dir)
+ except OSError as exc:
+ console.print(
+ f"[red]Error:[/red] Failed to install workflow "
+ f"'{_escape_markup(definition.id)}': {_escape_markup(str(exc))}"
+ )
+ raise typer.Exit(1)
+
+ try:
+ # Write the exact bytes parsed above so a concurrent source edit
+ # cannot desynchronize installed content from validated metadata.
+ staged_file.write_bytes(source_content)
+ staged_file.set_mode(source_mode)
+ except OSError as exc:
+ _safe_discard_staged_workflow_file(staged_file, dest_dir, existed_before)
+ console.print(
+ f"[red]Error:[/red] Failed to install workflow "
+ f"'{_escape_markup(definition.id)}': {_escape_markup(str(exc))}"
+ )
+ raise typer.Exit(1)
+
+ try:
+ transaction = _workflow_install_transaction(project_root)
+ with transaction:
+ transaction_existed_before = existed_before or dest_file.exists()
+ transaction_registry = _open_workflow_registry(project_root)
+ # Commit the staged copy onto dest_file via an atomic swap. A
+ # prior file is renamed aside so registry failure can restore it.
+ try:
+ backup_file = _commit_workflow_file(
+ staged_file, dest_file, transaction_existed_before
+ )
+ except OSError as exc:
+ _safe_discard_staged_workflow_file(
+ staged_file, dest_dir, existed_before
+ )
+ console.print(
+ f"[red]Error:[/red] Failed to install workflow "
+ f"'{_escape_markup(definition.id)}': "
+ f"{_escape_markup(str(exc))}"
+ )
+ raise typer.Exit(1)
+ try:
+ entry = {
+ "name": definition.name,
+ "version": definition.version,
+ "description": definition.description,
+ "source": source_label,
+ }
+ existing = transaction_registry.get(definition.id)
+ if isinstance(existing, dict) and not existing.get(
+ "enabled", True
+ ):
+ entry["enabled"] = False
+ transaction_registry.add(definition.id, entry)
+ except (OSError, TypeError, ValueError) as exc:
+ _safe_rollback_committed_workflow_file(
+ dest_file,
+ dest_dir,
+ transaction_existed_before,
+ backup_file,
+ )
+ console.print(
+ f"[red]Error:[/red] Failed to update workflow registry for "
+ f"'{_escape_markup(definition.id)}': "
+ f"{_escape_markup(str(exc))}"
+ )
+ raise typer.Exit(1)
+ # Registry update succeeded while the transaction lock is held.
+ _discard_committed_backup_file(backup_file)
+ except typer.Exit:
+ _safe_discard_staged_workflow_file(
+ staged_file, dest_dir, existed_before
+ )
+ raise
+ except OSError as exc:
+ _safe_discard_staged_workflow_file(staged_file, dest_dir, existed_before)
+ console.print(
+ f"[red]Error:[/red] Failed to lock workflow install "
+ f"'{_escape_markup(definition.id)}': {_escape_markup(str(exc))}"
+ )
+ raise typer.Exit(1)
+ console.print(
+ f"[green]βœ“[/green] Workflow '{_escape_markup(definition.name)}' "
+ f"({_escape_markup(definition.id)}) installed"
+ )
+
+ # Explicit local install (mirrors `extension add --dev`). --dev takes
+ # precedence over --from so a URL that would be ignored is never fetched.
+ if dev:
+ dev_path = Path(source).expanduser()
+ if dev_path.is_file() and dev_path.suffix in (".yml", ".yaml"):
+ _validate_and_install_local(dev_path, str(dev_path))
+ return
+ if dev_path.is_dir():
+ dev_wf_file = dev_path / "workflow.yml"
+ if not dev_wf_file.is_file():
+ console.print(f"[red]Error:[/red] No workflow.yml found in {_escape_markup(source)}")
+ raise typer.Exit(1)
+ _validate_and_install_local(dev_wf_file, str(dev_path))
+ return
+ console.print(
+ "[red]Error:[/red] --dev source must be a workflow YAML file or a "
+ f"directory containing workflow.yml: {_escape_markup(source)}"
+ )
+ raise typer.Exit(1)
+
+ # Try as URL (http/https) β€” either the positional source is a URL, or an
+ # explicit --from URL names where to fetch it (mirrors `extension add --from`).
+ download_url = (
+ from_url
+ if from_url is not None
+ else (source if source.startswith(("http://", "https://")) else None)
+ )
+ if download_url is not None:
from ipaddress import ip_address
from urllib.parse import urlparse
from specify_cli.authentication.http import open_url as _open_url
try:
- parsed_src = urlparse(source)
+ parsed_src = urlparse(download_url)
except ValueError:
- console.print(f"[red]Error:[/red] Invalid URL: {_escape_markup(source)}")
+ console.print(f"[red]Error:[/red] Invalid URL: {_escape_markup(download_url)}")
raise typer.Exit(1)
src_host = parsed_src.hostname or ""
src_loopback = src_host == "localhost"
@@ -656,20 +1585,52 @@ def workflow_add(
console.print("[red]Error:[/red] Only HTTPS URLs are allowed, except HTTP for localhost.")
raise typer.Exit(1)
+ if from_url is not None:
+ from rich.panel import Panel
+
+ safe_url = _escape_markup(from_url)
+ console.print()
+ console.print(
+ Panel(
+ "[bold]You are installing a workflow from an external URL "
+ "that is not\nlisted in any of your configured workflow "
+ "catalogs.[/bold]\n\n"
+ f"URL: {safe_url}\n\n"
+ "Only install workflows from sources you trust.",
+ title="[bold yellow]⚠ Untrusted Source[/bold yellow]",
+ border_style="yellow",
+ padding=(1, 2),
+ )
+ )
+ console.print()
+ if not typer.confirm("Continue with installation?", default=False):
+ console.print("Cancelled")
+ raise typer.Exit(0)
+
from specify_cli._github_http import resolve_github_release_asset_api_url as _resolve_gh_asset
from specify_cli.authentication.http import github_provider_hosts as _github_provider_hosts
_wf_url_extra_headers = None
_resolved_wf_url = _resolve_gh_asset(
- source, _open_url, timeout=30, github_hosts=_github_provider_hosts()
+ download_url,
+ _open_url,
+ timeout=30,
+ github_hosts=_github_provider_hosts(),
+ redirect_validator=_reject_insecure_download_redirect,
)
if _resolved_wf_url:
- source = _resolved_wf_url
+ download_url = _resolved_wf_url
_wf_url_extra_headers = {"Accept": "application/octet-stream"}
import tempfile
+ tmp_path: Path | None = None
try:
- with _open_url(source, timeout=30, extra_headers=_wf_url_extra_headers) as resp:
+ with _open_url(
+ download_url,
+ timeout=30,
+ extra_headers=_wf_url_extra_headers,
+ redirect_validator=_reject_insecure_download_redirect,
+ ) as resp:
final_url = resp.geturl()
final_parsed = urlparse(final_url)
final_host = final_parsed.hostname or ""
@@ -681,20 +1642,58 @@ def workflow_add(
# Redirect host is not an IP literal; keep loopback as determined above.
pass
if final_parsed.scheme != "https" and not (final_parsed.scheme == "http" and final_lb):
- console.print(f"[red]Error:[/red] URL redirected to non-HTTPS: {final_url}")
+ console.print(
+ f"[red]Error:[/red] URL redirected to non-HTTPS: {_escape_markup(final_url)}"
+ )
raise typer.Exit(1)
with tempfile.NamedTemporaryFile(suffix=".yml", delete=False) as tmp:
- tmp.write(resp.read())
+ # Assign tmp_path immediately: NamedTemporaryFile(delete=False)
+ # creates the file on disk right away, before any bytes are
+ # written, so a failure in the size-limited read below must
+ # still be able to find and remove it.
tmp_path = Path(tmp.name)
+ tmp.write(_read_response_within_limit(resp))
except typer.Exit:
raise
except Exception as exc:
- console.print(f"[red]Error:[/red] Failed to download workflow: {exc}")
+ if tmp_path is not None:
+ # A cleanup failure here must never replace/mask the
+ # original download error below with a raw, unhandled
+ # OSError -- warn about it and keep going, exactly like the
+ # later post-install finally cleanup does.
+ try:
+ tmp_path.unlink(missing_ok=True)
+ except OSError as cleanup_exc:
+ console.print(
+ "[yellow]Warning:[/yellow] Could not remove temporary "
+ f"download file {_escape_markup(str(tmp_path))}: "
+ f"{_escape_markup(str(cleanup_exc))}"
+ )
+ console.print(f"[red]Error:[/red] Failed to download workflow: {_escape_markup(str(exc))}")
raise typer.Exit(1)
try:
- _validate_and_install_local(tmp_path, source)
+ # When installed via --from, the positional argument names the
+ # workflow the user expects β€” enforce it like the catalog branch.
+ _validate_and_install_local(
+ tmp_path,
+ download_url,
+ expected_id=source if from_url else None,
+ )
finally:
- tmp_path.unlink(missing_ok=True)
+ # Best-effort: _validate_and_install_local may already have
+ # committed the file + registry entry (success) or already
+ # raised its own clean typer.Exit (failure) by this point --
+ # either way, a cleanup OSError here must never mask that
+ # outcome or surface as its own unhandled failure. Warn instead,
+ # same as the committed-backup cleanup above.
+ try:
+ tmp_path.unlink(missing_ok=True)
+ except OSError as exc:
+ console.print(
+ "[yellow]Warning:[/yellow] Could not remove temporary "
+ f"download file {_escape_markup(str(tmp_path))}: "
+ f"{_escape_markup(str(exc))}"
+ )
return
# Try as a local file/directory
@@ -705,40 +1704,86 @@ def workflow_add(
return
elif source_path.is_dir():
wf_file = source_path / "workflow.yml"
- if not wf_file.exists():
- console.print(f"[red]Error:[/red] No workflow.yml found in {source}")
+ if not wf_file.is_file():
+ console.print(f"[red]Error:[/red] No workflow.yml found in {_escape_markup(source)}")
raise typer.Exit(1)
_validate_and_install_local(wf_file, str(source_path))
return
# Try from catalog
+ _install_workflow_from_catalog(project_root, workflows_dir, source)
+
+
+def _install_workflow_from_catalog(
+ project_root: Path,
+ workflows_dir: Path,
+ workflow_id: str,
+ expected_version: str | None = None,
+ expected_installed_version: str | None = None,
+) -> None:
+ """Download, validate, and register a catalog workflow.
+
+ Shared by ``workflow add`` and ``workflow update``. Raises ``typer.Exit``
+ on any failure; the registry entry is only written on full success.
+ ``expected_version``, when given, rejects a downloaded workflow whose
+ version does not match the catalog version that triggered the install.
+ ``expected_installed_version``, when given by ``workflow update``, aborts
+ if another process changes the installed source or version before commit.
+ """
+ from .catalog import WorkflowCatalog, WorkflowCatalogError
+ from .engine import WorkflowDefinition
+
+ def versions_match(actual: object, expected: str) -> bool:
+ from packaging import version as pkg_version
+
+ try:
+ return pkg_version.Version(str(actual)) == pkg_version.Version(
+ expected
+ )
+ except pkg_version.InvalidVersion:
+ return str(actual) == expected
+
+ safe_wf_id = _escape_markup(workflow_id)
+
catalog = WorkflowCatalog(project_root)
try:
- info = catalog.get_workflow_info(source)
+ info = catalog.get_workflow_info(workflow_id)
except WorkflowCatalogError as exc:
- console.print(f"[red]Error:[/red] {exc}")
+ console.print(f"[red]Error:[/red] {_escape_markup(str(exc))}")
raise typer.Exit(1)
if not info:
- console.print(f"[red]Error:[/red] Workflow '{source}' not found in catalog")
+ console.print(f"[red]Error:[/red] Workflow '{safe_wf_id}' not found in catalog")
raise typer.Exit(1)
if not info.get("_install_allowed", True):
- console.print(f"[yellow]Warning:[/yellow] Workflow '{source}' is from a discovery-only catalog")
+ console.print(f"[yellow]Warning:[/yellow] Workflow '{safe_wf_id}' is from a discovery-only catalog")
console.print("Direct installation is not enabled for this catalog source.")
raise typer.Exit(1)
workflow_url = info.get("url")
if not workflow_url:
- console.print(f"[red]Error:[/red] Workflow '{source}' does not have an install URL in the catalog")
+ console.print(f"[red]Error:[/red] Workflow '{safe_wf_id}' does not have an install URL in the catalog")
+ raise typer.Exit(1)
+ if not isinstance(workflow_url, str):
+ # Untrusted catalog payload; a non-string would crash urlparse below.
+ console.print(
+ f"[red]Error:[/red] Workflow '{safe_wf_id}' has a malformed install URL."
+ )
raise typer.Exit(1)
# Validate URL scheme (HTTPS required, HTTP allowed for localhost only)
from ipaddress import ip_address
from urllib.parse import urlparse
- parsed_url = urlparse(workflow_url)
- url_host = parsed_url.hostname or ""
+ try:
+ parsed_url = urlparse(workflow_url)
+ url_host = parsed_url.hostname or ""
+ except ValueError:
+ console.print(
+ f"[red]Error:[/red] Workflow '{safe_wf_id}' has a malformed install URL."
+ )
+ raise typer.Exit(1)
is_loopback = False
if url_host == "localhost":
is_loopback = True
@@ -750,16 +1795,33 @@ def workflow_add(
pass
if parsed_url.scheme != "https" and not (parsed_url.scheme == "http" and is_loopback):
console.print(
- f"[red]Error:[/red] Workflow '{source}' has an invalid install URL. "
+ f"[red]Error:[/red] Workflow '{safe_wf_id}' has an invalid install URL. "
"Only HTTPS URLs are allowed, except HTTP for localhost/loopback."
)
raise typer.Exit(1)
# Reject path traversal, symlinked <id>, and a symlinked workflow.yml leaf
# before any mkdir/download writes beneath the install directory.
- workflow_dir = _safe_workflow_id_dir(workflows_dir, source)
+ workflow_dir = _safe_workflow_id_dir(workflows_dir, workflow_id)
workflow_file = workflow_dir / "workflow.yml"
+ # Captured before any mkdir/download writes so every failure branch below
+ # can tell a fresh install from a reinstall-over-an-existing-one,
+ # mirroring _validate_and_install_local's existed-before-aware cleanup.
+ existed_before = workflow_dir.is_dir()
+
+ try:
+ staged_file = _stage_workflow_file(
+ workflow_dir,
+ use_project_file_mode=not workflow_file.exists(),
+ )
+ except OSError as exc:
+ console.print(
+ f"[red]Error:[/red] Failed to install workflow '{safe_wf_id}' from catalog: "
+ f"{_escape_markup(str(exc))}"
+ )
+ raise typer.Exit(1)
+
try:
from specify_cli.authentication.http import open_url as _open_url
from specify_cli.authentication.http import github_provider_hosts as _github_provider_hosts
@@ -767,14 +1829,22 @@ def workflow_add(
_wf_cat_extra_headers = None
_resolved_workflow_url = _resolve_gh_asset(
- workflow_url, _open_url, timeout=30, github_hosts=_github_provider_hosts()
+ workflow_url,
+ _open_url,
+ timeout=30,
+ github_hosts=_github_provider_hosts(),
+ redirect_validator=_reject_insecure_download_redirect,
)
if _resolved_workflow_url:
workflow_url = _resolved_workflow_url
_wf_cat_extra_headers = {"Accept": "application/octet-stream"}
- workflow_dir.mkdir(parents=True, exist_ok=True)
- with _open_url(workflow_url, timeout=30, extra_headers=_wf_cat_extra_headers) as response:
+ with _open_url(
+ workflow_url,
+ timeout=30,
+ extra_headers=_wf_cat_extra_headers,
+ redirect_validator=_reject_insecure_download_redirect,
+ ) as response:
# Validate final URL after redirects
final_url = response.geturl()
final_parsed = urlparse(final_url)
@@ -787,82 +1857,168 @@ def workflow_add(
# Host is not an IP literal (e.g., a regular hostname); treat as non-loopback.
pass
if final_parsed.scheme != "https" and not (final_parsed.scheme == "http" and final_loopback):
- if workflow_dir.exists():
- import shutil
- shutil.rmtree(workflow_dir, ignore_errors=True)
+ _safe_discard_staged_workflow_file(staged_file, workflow_dir, existed_before)
console.print(
- f"[red]Error:[/red] Workflow '{source}' redirected to non-HTTPS URL: {final_url}"
+ f"[red]Error:[/red] Workflow '{safe_wf_id}' redirected to non-HTTPS URL: {_escape_markup(final_url)}"
)
raise typer.Exit(1)
- workflow_file.write_bytes(response.read())
+ # Written to the staging file, never workflow_file directly, so a
+ # reinstall's prior working copy is never touched until the
+ # atomic commit below runs.
+ downloaded_content = _read_response_within_limit(response)
+ staged_file.write_bytes(downloaded_content)
+ except typer.Exit:
+ raise
except Exception as exc:
- if workflow_dir.exists():
- import shutil
- shutil.rmtree(workflow_dir, ignore_errors=True)
- console.print(f"[red]Error:[/red] Failed to install workflow '{source}' from catalog: {exc}")
+ _safe_discard_staged_workflow_file(staged_file, workflow_dir, existed_before)
+ console.print(f"[red]Error:[/red] Failed to install workflow '{safe_wf_id}' from catalog: {_escape_markup(str(exc))}")
raise typer.Exit(1)
- # Validate the downloaded workflow before registering
+ # Validate the downloaded workflow (still staged, not yet committed)
+ # before registering.
try:
- definition = WorkflowDefinition.from_yaml(workflow_file)
- except (ValueError, yaml.YAMLError) as exc:
- import shutil
- shutil.rmtree(workflow_dir, ignore_errors=True)
- console.print(f"[red]Error:[/red] Downloaded workflow is invalid: {exc}")
+ definition = WorkflowDefinition.from_string(
+ downloaded_content.decode("utf-8")
+ )
+ except (UnicodeDecodeError, ValueError, yaml.YAMLError) as exc:
+ _safe_discard_staged_workflow_file(staged_file, workflow_dir, existed_before)
+ console.print(f"[red]Error:[/red] Downloaded workflow is invalid: {_escape_markup(str(exc))}")
raise typer.Exit(1)
from .engine import validate_workflow
errors = validate_workflow(definition)
if errors:
- import shutil
- shutil.rmtree(workflow_dir, ignore_errors=True)
+ _safe_discard_staged_workflow_file(staged_file, workflow_dir, existed_before)
console.print("[red]Error:[/red] Downloaded workflow validation failed:")
for err in errors:
- console.print(f" \u2022 {err}")
+ console.print(f" \u2022 {_escape_markup(str(err))}")
raise typer.Exit(1)
# Enforce that the workflow's internal ID matches the catalog key
- if definition.id and definition.id != source:
- import shutil
- shutil.rmtree(workflow_dir, ignore_errors=True)
+ if definition.id and definition.id != workflow_id:
+ _safe_discard_staged_workflow_file(staged_file, workflow_dir, existed_before)
console.print(
- f"[red]Error:[/red] Workflow ID in YAML ({definition.id!r}) "
- f"does not match catalog key ({source!r}). "
+ f"[red]Error:[/red] Workflow ID in YAML ({_escape_markup(repr(definition.id))}) "
+ f"does not match catalog key ({_escape_markup(repr(workflow_id))}). "
f"The catalog entry may be misconfigured."
)
raise typer.Exit(1)
- registry.add(source, {
- "name": definition.name or info.get("name", source),
- "version": definition.version or info.get("version", "0.0.0"),
- "description": definition.description or info.get("description", ""),
- "source": "catalog",
- "catalog_name": info.get("_catalog_name", ""),
- "url": workflow_url,
- })
- console.print(f"[green]βœ“[/green] Workflow '{info.get('name', source)}' installed from catalog")
-
+ # A stale or misconfigured URL can serve a different version than the
+ # catalog advertised; without this check `update` would report success
+ # while leaving the old version installed (or even downgrading).
+ if expected_version is not None:
+ if not versions_match(definition.version, expected_version):
+ _safe_discard_staged_workflow_file(staged_file, workflow_dir, existed_before)
+ console.print(
+ f"[red]Error:[/red] Downloaded workflow version ({_escape_markup(str(definition.version))}) "
+ f"does not match the catalog version ({_escape_markup(expected_version)}). "
+ f"The catalog entry may be stale or misconfigured."
+ )
+ raise typer.Exit(1)
-@workflow_app.command("remove")
-def workflow_remove(
- workflow_id: str = typer.Argument(..., help="Workflow ID to uninstall"),
-):
- """Uninstall a workflow."""
- from .catalog import WorkflowRegistry
+ try:
+ transaction = _workflow_install_transaction(project_root)
+ with transaction:
+ transaction_existed_before = (
+ existed_before or workflow_file.exists()
+ )
+ transaction_registry = _open_workflow_registry(project_root)
+ if expected_installed_version is not None:
+ current = transaction_registry.get(workflow_id)
+ if (
+ not isinstance(current, dict)
+ or current.get("source") != "catalog"
+ or not versions_match(
+ current.get("version"), expected_installed_version
+ )
+ ):
+ console.print(
+ f"[yellow]Warning:[/yellow] Workflow '{safe_wf_id}' "
+ "changed during update; rerun the command to use its "
+ "current source and version."
+ )
+ raise typer.Exit(1)
+ # Commit the staged download onto workflow_file via an atomic
+ # swap. A prior file is renamed aside for registry rollback.
+ try:
+ backup_file = _commit_workflow_file(
+ staged_file, workflow_file, transaction_existed_before
+ )
+ except OSError as exc:
+ _safe_discard_staged_workflow_file(
+ staged_file, workflow_dir, existed_before
+ )
+ console.print(
+ f"[red]Error:[/red] Failed to install workflow "
+ f"'{safe_wf_id}' from catalog: {_escape_markup(str(exc))}"
+ )
+ raise typer.Exit(1)
- project_root = _require_specify_project()
- workflows_dir = project_root / ".specify" / "workflows"
- _validate_workflow_id_or_exit(workflow_id)
+ entry = {
+ "name": definition.name or info.get("name", workflow_id),
+ "version": definition.version or info.get("version", "0.0.0"),
+ "description": definition.description
+ or info.get("description", ""),
+ "source": "catalog",
+ "catalog_name": info.get("_catalog_name", ""),
+ "url": workflow_url,
+ }
+ # Preserve a prior disabled state across updates/reinstalls.
+ existing = transaction_registry.get(workflow_id)
+ if isinstance(existing, dict) and not existing.get(
+ "enabled", True
+ ):
+ entry["enabled"] = False
+ try:
+ transaction_registry.add(workflow_id, entry)
+ except (OSError, TypeError, ValueError) as exc:
+ _safe_rollback_committed_workflow_file(
+ workflow_file,
+ workflow_dir,
+ transaction_existed_before,
+ backup_file,
+ )
+ console.print(
+ f"[red]Error:[/red] Failed to update workflow registry for "
+ f"'{_escape_markup(workflow_id)}': "
+ f"{_escape_markup(str(exc))}"
+ )
+ raise typer.Exit(1)
+ # Registry update succeeded while the transaction lock is held.
+ _discard_committed_backup_file(backup_file)
+ except typer.Exit:
+ _safe_discard_staged_workflow_file(
+ staged_file, workflow_dir, existed_before
+ )
+ raise
+ except OSError as exc:
+ _safe_discard_staged_workflow_file(staged_file, workflow_dir, existed_before)
+ console.print(
+ f"[red]Error:[/red] Failed to lock workflow install "
+ f"'{safe_wf_id}': "
+ f"{_escape_markup(str(exc))}"
+ )
+ raise typer.Exit(1)
+ console.print(
+ f"[green]βœ“[/green] Workflow '{_escape_markup(str(info.get('name', workflow_id)))}' "
+ "installed from catalog"
+ )
- registry = WorkflowRegistry(project_root)
+def _remove_workflow_locked(
+ project_root: Path, workflows_dir: Path, workflow_id: str
+) -> Path | None:
+ """Stage a workflow directory and persist removal while locked."""
+ registry = _open_workflow_registry(project_root)
+ safe_id = _escape_markup(workflow_id)
if not registry.is_installed(workflow_id):
- console.print(f"[red]Error:[/red] Workflow '{workflow_id}' is not installed")
+ console.print(
+ f"[red]Error:[/red] Workflow '{safe_id}' is not installed"
+ )
raise typer.Exit(1)
- # Remove workflow files
workflow_dir_unresolved = workflows_dir / workflow_id
- safe_id = _escape_markup(workflow_id)
if workflow_dir_unresolved.is_symlink():
console.print(
f"[red]Error:[/red] Refusing to remove symlinked "
@@ -875,39 +2031,301 @@ def workflow_remove(
rel_parts = workflow_dir.relative_to(workflows_dir.resolve()).parts
except ValueError:
console.print(
- f"[red]Error:[/red] Invalid workflow ID: {_escape_markup(repr(workflow_id))}"
+ f"[red]Error:[/red] Invalid workflow ID: "
+ f"{_escape_markup(repr(workflow_id))}"
)
raise typer.Exit(1)
if rel_parts != (workflow_id,):
console.print(
- f"[red]Error:[/red] Invalid workflow ID: {_escape_markup(repr(workflow_id))}"
+ f"[red]Error:[/red] Invalid workflow ID: "
+ f"{_escape_markup(repr(workflow_id))}"
)
raise typer.Exit(1)
if workflow_dir.exists() and not workflow_dir.is_dir():
console.print(
- f"[red]Error:[/red] .specify/workflows/{safe_id} exists but is not a directory"
+ f"[red]Error:[/red] .specify/workflows/{safe_id} exists "
+ "but is not a directory"
)
raise typer.Exit(1)
+ import tempfile
+
+ staged_dir: Path | None = None
if workflow_dir.exists():
- import shutil
try:
- shutil.rmtree(workflow_dir)
+ reserved = Path(
+ tempfile.mkdtemp(
+ prefix=f".{workflow_id}.removing-", dir=workflows_dir
+ )
+ )
+ reserved.rmdir()
+ os.rename(workflow_dir, reserved)
+ staged_dir = reserved
except OSError as exc:
console.print(
- f"[red]Error:[/red] Failed to remove workflow directory {workflow_dir}: {exc}"
+ f"[red]Error:[/red] Failed to stage workflow directory "
+ f"{_escape_markup(str(workflow_dir))} for removal: "
+ f"{_escape_markup(str(exc))}"
)
raise typer.Exit(1)
- registry.remove(workflow_id)
+ try:
+ registry.remove(workflow_id)
+ except (OSError, TypeError, ValueError) as exc:
+ if staged_dir is not None:
+ try:
+ os.rename(staged_dir, workflow_dir)
+ except OSError as restore_exc:
+ console.print(
+ f"[yellow]Warning:[/yellow] Failed to restore workflow "
+ "directory after registry update failure; it remains "
+ f"staged at {_escape_markup(str(staged_dir))}: "
+ f"{_escape_markup(str(restore_exc))}"
+ )
+ console.print(
+ f"[red]Error:[/red] Failed to update workflow registry for "
+ f"'{safe_id}': {_escape_markup(str(exc))}"
+ )
+ raise typer.Exit(1)
+ return staged_dir
+
+
+@workflow_app.command("remove")
+def workflow_remove(
+ workflow_id: str = typer.Argument(..., help="Workflow ID to uninstall"),
+):
+ """Uninstall a workflow."""
+ project_root = _require_specify_project()
+ workflows_dir = project_root / ".specify" / "workflows"
+ _validate_workflow_id_or_exit(workflow_id)
+ safe_id = _escape_markup(workflow_id)
+ import shutil
+ try:
+ with _workflow_install_transaction(project_root):
+ staged_dir = _remove_workflow_locked(
+ project_root, workflows_dir, workflow_id
+ )
+ except OSError as exc:
+ console.print(
+ f"[red]Error:[/red] Failed to lock workflow removal "
+ f"'{safe_id}': {_escape_markup(str(exc))}"
+ )
+ raise typer.Exit(1)
+
console.print(f"[green]βœ“[/green] Workflow '{workflow_id}' removed")
+ # The registry has already durably committed the removal at this point,
+ # so it must stand regardless of what happens below: deleting the staged
+ # directory is now just cleanup, not a data-integrity concern, and a
+ # failure here is reported as a warning (not an error) to avoid
+ # contradicting the registry state that already succeeded.
+ if staged_dir is not None:
+ try:
+ shutil.rmtree(staged_dir)
+ except OSError as exc:
+ console.print(
+ f"[yellow]Warning:[/yellow] Workflow '{safe_id}' was removed, but its "
+ f"staged directory could not be deleted: {_escape_markup(str(exc))}. "
+ f"Remove it manually: {_escape_markup(str(staged_dir))}"
+ )
+
+
+@workflow_app.command("update")
+def workflow_update(
+ workflow_id: str | None = typer.Argument(None, help="Workflow ID to update (default: all)"),
+):
+ """Update installed workflow(s) to the latest catalog version."""
+ from packaging import version as pkg_version
+
+ from .catalog import WorkflowCatalog, WorkflowCatalogError
+
+ project_root = _require_specify_project()
+ registry = _open_workflow_registry(project_root)
+ workflows_dir = project_root / ".specify" / "workflows"
+ _reject_unsafe_dir(project_root / ".specify", ".specify")
+ _reject_unsafe_dir(workflows_dir, ".specify/workflows")
+
+ installed = registry.list()
+ if workflow_id:
+ if not registry.is_installed(workflow_id):
+ console.print(f"[red]Error:[/red] Workflow '{_escape_markup(workflow_id)}' is not installed")
+ raise typer.Exit(1)
+ targets = [workflow_id]
+ else:
+ targets = list(installed)
+
+ if not targets:
+ console.print("[yellow]No workflows installed[/yellow]")
+ raise typer.Exit(0)
+
+ catalog = WorkflowCatalog(project_root)
+ console.print("πŸ”„ Checking for updates...\n")
+
+ updates_available: list[dict[str, str]] = []
+ checked = 0
+ for wf_id in targets:
+ safe_id = _escape_markup(str(wf_id))
+ metadata = installed.get(wf_id)
+ if not isinstance(metadata, dict):
+ console.print(f"⚠ {safe_id}: Registry entry is corrupted (skipping)")
+ continue
+ if metadata.get("source") != "catalog":
+ console.print(f"⚠ {safe_id}: Not installed from a catalog β€” re-add to update (skipping)")
+ continue
+ try:
+ installed_version = pkg_version.Version(str(metadata.get("version")))
+ except pkg_version.InvalidVersion:
+ console.print(
+ f"⚠ {safe_id}: Invalid installed version '{_escape_markup(str(metadata.get('version')))}' in registry (skipping)"
+ )
+ continue
+ try:
+ info = catalog.get_workflow_info(wf_id)
+ except WorkflowCatalogError as exc:
+ console.print(f"[red]Error:[/red] {_escape_markup(str(exc))}")
+ raise typer.Exit(1)
+ if not info:
+ console.print(f"⚠ {safe_id}: Not found in catalog (skipping)")
+ continue
+ if not info.get("_install_allowed", True):
+ console.print(
+ f"⚠ {safe_id}: Updates not allowed from '{_escape_markup(str(info.get('_catalog_name', 'catalog')))}' (skipping)"
+ )
+ continue
+ try:
+ catalog_version = pkg_version.Version(str(info.get("version")))
+ except pkg_version.InvalidVersion:
+ console.print(
+ f"⚠ {safe_id}: Invalid catalog version '{_escape_markup(str(info.get('version')))}' (skipping)"
+ )
+ continue
+ if catalog_version > installed_version:
+ checked += 1
+ updates_available.append(
+ {"id": wf_id, "installed": str(installed_version), "available": str(catalog_version)}
+ )
+ else:
+ checked += 1
+ console.print(f"βœ“ {safe_id}: Up to date (v{installed_version})")
+
+ if not updates_available:
+ if not checked:
+ console.print("\n[yellow]No workflows were eligible for update[/yellow]")
+ elif checked == len(targets):
+ console.print("\n[green]All workflows are up to date![/green]")
+ else:
+ console.print(
+ f"\n[green]All checked workflows are up to date[/green] "
+ f"[yellow]({len(targets) - checked} skipped)[/yellow]"
+ )
+ raise typer.Exit(0)
+
+ console.print("\n[bold]Updates available:[/bold]\n")
+ for update in updates_available:
+ console.print(
+ f" β€’ {_escape_markup(update['id'])}: {update['installed']} β†’ {update['available']}"
+ )
+ console.print()
+ if not typer.confirm("Update these workflows?"):
+ console.print("Cancelled")
+ raise typer.Exit(0)
+
+ console.print()
+ failed: list[str] = []
+ for update in updates_available:
+ # _install_workflow_from_catalog is fully transactional (staged
+ # download, atomic commit, rename-based rollback on registry
+ # failure): it never leaves a partially-written workflow.yml, so
+ # this loop only needs to record success/failure, not perform its
+ # own backup/restore.
+ try:
+ _install_workflow_from_catalog(
+ project_root, workflows_dir, update["id"],
+ expected_version=update["available"],
+ expected_installed_version=update["installed"],
+ )
+ except (typer.Exit, OSError) as exc:
+ if isinstance(exc, OSError):
+ console.print(
+ f"[red]Error:[/red] Filesystem error updating "
+ f"'{_escape_markup(update['id'])}': {_escape_markup(str(exc))}"
+ )
+ failed.append(update["id"])
+
+ if failed:
+ console.print(
+ f"\n[red]Failed to update:[/red] {', '.join(_escape_markup(f) for f in failed)}"
+ )
+ raise typer.Exit(1)
+
+
+def _set_workflow_enabled(workflow_id: str, enabled: bool) -> None:
+ """Update enabled state from a fresh registry snapshot while locked."""
+ project_root = _require_specify_project()
+ safe_id = _escape_markup(workflow_id)
+ try:
+ with _workflow_install_transaction(project_root):
+ registry = _open_workflow_registry(project_root)
+ metadata = registry.get(workflow_id)
+ if metadata is None:
+ console.print(
+ f"[red]Error:[/red] Workflow '{safe_id}' is not installed"
+ )
+ raise typer.Exit(1)
+ if not isinstance(metadata, dict):
+ console.print(
+ f"[red]Error:[/red] Registry entry for '{safe_id}' "
+ "is corrupted"
+ )
+ raise typer.Exit(1)
+ current = bool(metadata.get("enabled", True))
+ state = "enabled" if enabled else "disabled"
+ if current is enabled:
+ console.print(
+ f"[yellow]Workflow '{safe_id}' is already {state}[/yellow]"
+ )
+ raise typer.Exit(0)
+ try:
+ registry.add(workflow_id, {**metadata, "enabled": enabled})
+ except OSError as exc:
+ console.print(
+ f"[red]Error:[/red] Failed to update workflow registry "
+ f"for '{safe_id}': {_escape_markup(str(exc))}"
+ )
+ raise typer.Exit(1)
+ except OSError as exc:
+ console.print(
+ f"[red]Error:[/red] Failed to lock workflow registry for "
+ f"'{safe_id}': {_escape_markup(str(exc))}"
+ )
+ raise typer.Exit(1)
+ state = "enabled" if enabled else "disabled"
+ console.print(f"[green]βœ“[/green] Workflow '{safe_id}' {state}")
+
+
+@workflow_app.command("enable")
+def workflow_enable(
+ workflow_id: str = typer.Argument(..., help="Workflow ID to enable"),
+):
+ """Enable a disabled workflow."""
+ _set_workflow_enabled(workflow_id, True)
+
+
+@workflow_app.command("disable")
+def workflow_disable(
+ workflow_id: str = typer.Argument(..., help="Workflow ID to disable"),
+):
+ """Disable a workflow without removing it."""
+ _set_workflow_enabled(workflow_id, False)
+ console.print(f"To re-enable: specify workflow enable {_escape_markup(workflow_id)}")
+
@workflow_app.command("search")
def workflow_search(
query: str | None = typer.Argument(None, help="Search query"),
tag: str | None = typer.Option(None, "--tag", help="Filter by tag"),
+ author: str | None = typer.Option(None, "--author", help="Filter by author"),
):
"""Search workflow catalogs."""
from .catalog import WorkflowCatalog, WorkflowCatalogError
@@ -916,9 +2334,9 @@ def workflow_search(
catalog = WorkflowCatalog(project_root)
try:
- results = catalog.search(query=query, tag=tag)
+ results = catalog.search(query=query, tag=tag, author=author)
except WorkflowCatalogError as exc:
- console.print(f"[red]Error:[/red] {exc}")
+ console.print(f"[red]Error:[/red] {_escape_markup(str(exc))}")
raise typer.Exit(1)
if not results:
@@ -927,13 +2345,17 @@ def workflow_search(
console.print(f"\n[bold cyan]Workflows ({len(results)}):[/bold cyan]\n")
for wf in results:
- console.print(f" [bold]{wf.get('name', wf.get('id', '?'))}[/bold] ({wf.get('id', '?')}) v{wf.get('version', '?')}")
+ name = _escape_markup(str(wf.get("name", wf.get("id", "?"))))
+ wf_id = _escape_markup(str(wf.get("id", "?")))
+ version = _escape_markup(str(wf.get("version", "?")))
+ console.print(f" [bold]{name}[/bold] ({wf_id}) v{version}")
desc = wf.get("description", "")
if desc:
- console.print(f" {desc}")
+ console.print(f" {_escape_markup(str(desc))}")
tags = wf.get("tags", [])
if tags:
- console.print(f" [dim]Tags: {', '.join(tags)}[/dim]")
+ safe_tags = _escape_markup(", ".join(str(t) for t in tags))
+ console.print(f" [dim]Tags: {safe_tags}[/dim]")
console.print()
@@ -942,13 +2364,13 @@ def workflow_info(
workflow_id: str = typer.Argument(..., help="Workflow ID"),
):
"""Show workflow details and step graph."""
- from .catalog import WorkflowCatalog, WorkflowRegistry, WorkflowCatalogError
+ from .catalog import WorkflowCatalog, WorkflowCatalogError
from .engine import WorkflowEngine
project_root = _require_specify_project()
# Check installed first
- registry = WorkflowRegistry(project_root)
+ registry = _open_workflow_registry(project_root)
installed = registry.get(workflow_id)
engine = WorkflowEngine(project_root)
@@ -1264,7 +2686,9 @@ def workflow_step_add(
raise ValueError(f"Refusing to fetch from non-HTTPS URL: {url}")
if not parsed.hostname:
raise ValueError(f"Refusing to fetch from URL with no hostname: {url}")
- with _open_url(url, timeout=30) as resp:
+ with _open_url(
+ url, timeout=30, redirect_validator=_reject_insecure_download_redirect
+ ) as resp:
final_url = resp.geturl()
final_parsed = urlparse(final_url)
final_is_localhost = final_parsed.hostname in ("localhost", "127.0.0.1", "::1")
@@ -1274,7 +2698,7 @@ def workflow_step_add(
raise ValueError(f"Redirect to non-HTTPS URL: {final_url}")
if not final_parsed.hostname:
raise ValueError(f"Redirect to URL with no hostname: {final_url}")
- return resp.read()
+ return _read_response_within_limit(resp)
_validate_step_id_or_exit(step_id)
diff --git a/src/specify_cli/workflows/catalog.py b/src/specify_cli/workflows/catalog.py
index 294dd8759..654fa76e8 100644
--- a/src/specify_cli/workflows/catalog.py
+++ b/src/specify_cli/workflows/catalog.py
@@ -13,6 +13,8 @@ from __future__ import annotations
import hashlib
import json
import os
+import stat
+import tempfile
import time
from dataclasses import dataclass
from pathlib import Path
@@ -71,48 +73,180 @@ class WorkflowRegistry:
self.registry_path = self.workflows_dir / self.REGISTRY_FILE
self.data = self._load()
+ def _has_symlinked_parent(self) -> bool:
+ """Return True if any directory under .specify/workflows is a symlink."""
+ current = self.project_root
+ for part in (".specify", "workflows"):
+ current = current / part
+ if current.is_symlink():
+ return True
+ return False
+
def _load(self) -> dict[str, Any]:
"""Load registry from disk or create default."""
+ default_registry: dict[str, Any] = {
+ "schema_version": self.SCHEMA_VERSION,
+ "workflows": {},
+ }
+ # Defense-in-depth: refuse to read through symlinked parents or a
+ # symlinked registry file. Unlike StepRegistry (read-only best-effort
+ # elsewhere), a fabricated empty registry here is not safe: read-only
+ # callers (notably the bundler's remove path) query is_installed()
+ # before ever writing, and would otherwise conclude an installed
+ # workflow is absent, skip removing it, then delete the bundle
+ # record -- leaving the workflow untracked but still on disk. Fail
+ # closed here just like the unreadable-file case below.
+ if self._has_symlinked_parent() or self.registry_path.is_symlink():
+ raise OSError(
+ f"Refusing to read workflow registry at {self.registry_path}: "
+ "a parent directory or the registry file itself is a symlink"
+ )
if self.registry_path.exists():
try:
with open(self.registry_path, encoding="utf-8") as f:
data = json.load(f)
- # Validate shape: must be a dict with a dict "workflows" field,
- # otherwise every method that indexes data["workflows"] crashes.
- # Mirrors StepRegistry._load.
- if not isinstance(data, dict):
- return {"schema_version": self.SCHEMA_VERSION, "workflows": {}}
- if not isinstance(data.get("workflows"), dict):
- data["workflows"] = {}
- return data
- except (json.JSONDecodeError, ValueError, OSError, UnicodeError):
- # Corrupted registry file β€” reset to default
- return {"schema_version": self.SCHEMA_VERSION, "workflows": {}}
- return {"schema_version": self.SCHEMA_VERSION, "workflows": {}}
+ except OSError as exc:
+ # The real data may still be intact on disk. Fail closed at
+ # construction rather than fabricating an empty registry that
+ # a read-only caller could mistake for "nothing installed."
+ raise OSError(
+ f"Failed to read workflow registry at {self.registry_path}: {exc}"
+ ) from exc
+ except (
+ json.JSONDecodeError,
+ ValueError,
+ UnicodeError,
+ ) as exc:
+ raise OSError(
+ f"Workflow registry at {self.registry_path} is corrupted: "
+ f"{exc}"
+ ) from exc
+ # Validate shape: must be a dict with a dict "workflows" field.
+ if not isinstance(data, dict):
+ raise OSError(
+ f"Workflow registry at {self.registry_path} is corrupted: "
+ "top-level value must be an object"
+ )
+ if not isinstance(data.get("workflows"), dict):
+ raise OSError(
+ f"Workflow registry at {self.registry_path} is corrupted: "
+ "'workflows' must be an object"
+ )
+ return data
+ return default_registry
def save(self) -> None:
- """Persist registry to disk."""
+ """Persist registry to disk atomically."""
+ # Refuse to write through symlinked parents (mirrors StepRegistry.save
+ # and the CLI-level _reject_unsafe_dir guard).
+ if self._has_symlinked_parent() or self.registry_path.is_symlink():
+ raise OSError(
+ "Refusing to write workflow registry through a symlinked path."
+ )
self.workflows_dir.mkdir(parents=True, exist_ok=True)
- with open(self.registry_path, "w", encoding="utf-8") as f:
- json.dump(self.data, f, indent=2)
+ # Unique, exclusive temp then replace: a failed dump cannot truncate
+ # the registry, a pre-created symlink cannot redirect the write, and
+ # concurrent CLI processes cannot collide on the same temp path.
+ fd, tmp = tempfile.mkstemp(
+ dir=str(self.registry_path.parent),
+ prefix=f".{self.registry_path.name}.",
+ suffix=".tmp",
+ )
+ try:
+ # Write through a duplicate so the exclusive mkstemp descriptor
+ # stays open for fd-based metadata updates and inode verification.
+ with os.fdopen(os.dup(fd), "w", encoding="utf-8") as f:
+ json.dump(self.data, f, indent=2)
+ # mkstemp creates the temp file at 0600. A pre-existing registry
+ # may be shared more permissively (e.g. 0640/0644); preserve its
+ # mode across the replace so a save doesn't silently lock other
+ # project users out. A brand-new registry has no prior mode to
+ # preserve, so mkstemp's secure 0600 default stands. Mirrors
+ # _utils.py's atomic_write_json (best-effort; data safety over
+ # metadata preservation).
+ try:
+ if self.registry_path.exists():
+ existing_stat = self.registry_path.stat(
+ follow_symlinks=False
+ )
+ if stat.S_ISREG(existing_stat.st_mode) and hasattr(
+ os, "fchmod"
+ ):
+ os.fchmod(fd, stat.S_IMODE(existing_stat.st_mode))
+ if stat.S_ISREG(existing_stat.st_mode) and hasattr(
+ os, "fchown"
+ ):
+ try:
+ os.fchown(
+ fd, existing_stat.st_uid, existing_stat.st_gid
+ )
+ except PermissionError:
+ pass
+ except OSError:
+ pass
+ staged_stat = os.stat(tmp, follow_symlinks=False)
+ open_stat = os.fstat(fd)
+ if (
+ not stat.S_ISREG(staged_stat.st_mode)
+ or staged_stat.st_dev != open_stat.st_dev
+ or staged_stat.st_ino != open_stat.st_ino
+ ):
+ raise OSError(
+ "Refusing to replace workflow registry: "
+ "staged file changed before commit"
+ )
+ os.close(fd)
+ fd = -1
+ os.replace(tmp, self.registry_path)
+ except BaseException:
+ if fd >= 0:
+ try:
+ os.close(fd)
+ except OSError:
+ pass
+ try:
+ os.unlink(tmp)
+ except OSError:
+ pass
+ raise
def add(self, workflow_id: str, metadata: dict[str, Any]) -> None:
"""Add or update an installed workflow entry."""
from datetime import datetime, timezone
- existing = self.data["workflows"].get(workflow_id, {})
+ raw_existing = self.data["workflows"].get(workflow_id)
+ had_entry = workflow_id in self.data["workflows"]
+ # Corrupted-but-parseable registries may hold non-dict entries.
+ existing = raw_existing if isinstance(raw_existing, dict) else {}
metadata["installed_at"] = existing.get(
"installed_at", datetime.now(timezone.utc).isoformat()
)
metadata["updated_at"] = datetime.now(timezone.utc).isoformat()
self.data["workflows"][workflow_id] = metadata
- self.save()
+ try:
+ self.save()
+ except (OSError, TypeError, ValueError):
+ # Roll back the in-memory mutation so a later successful save
+ # cannot persist metadata for a write that failed.
+ if had_entry:
+ self.data["workflows"][workflow_id] = raw_existing
+ else:
+ del self.data["workflows"][workflow_id]
+ raise
def remove(self, workflow_id: str) -> bool:
"""Remove an installed workflow entry. Returns True if found."""
if workflow_id in self.data["workflows"]:
+ removed_entry = self.data["workflows"][workflow_id]
del self.data["workflows"][workflow_id]
- self.save()
+ try:
+ self.save()
+ except (OSError, TypeError, ValueError):
+ # Roll back the in-memory deletion so a save failure can't
+ # desync this instance from the untouched file on disk,
+ # mirroring add()'s rollback-on-save-failure.
+ self.data["workflows"][workflow_id] = removed_entry
+ raise
return True
return False
@@ -435,6 +569,7 @@ class WorkflowCatalog:
self,
query: str | None = None,
tag: str | None = None,
+ author: str | None = None,
) -> list[dict[str, Any]]:
"""Search workflows across all configured catalogs."""
merged = self._get_merged_workflows()
@@ -459,6 +594,10 @@ class WorkflowCatalog:
normalized_tags = [t.lower() for t in tags if isinstance(t, str)]
if tag.lower() not in normalized_tags:
continue
+ if author:
+ wf_author = wf_data.get("author", "")
+ if not isinstance(wf_author, str) or wf_author.lower() != author.lower():
+ continue
results.append(wf_data)
return results
diff --git a/src/specify_cli/workflows/engine.py b/src/specify_cli/workflows/engine.py
index fd207b9ec..ed52710be 100644
--- a/src/specify_cli/workflows/engine.py
+++ b/src/specify_cli/workflows/engine.py
@@ -150,7 +150,7 @@ def validate_workflow(definition: WorkflowDefinition) -> list[str]:
f"'workflow.id' must be a string, got "
f"{type(definition.id).__name__} ({definition.id!r})."
)
- elif not _ID_PATTERN.match(definition.id):
+ elif not _ID_PATTERN.fullmatch(definition.id):
errors.append(
f"Workflow ID {definition.id!r} must be lowercase alphanumeric "
f"with hyphens."
@@ -172,7 +172,7 @@ def validate_workflow(definition: WorkflowDefinition) -> list[str]:
f"{type(definition.version).__name__} ({definition.version!r}) β€” "
f'quote it in YAML (version: "1.0.0").'
)
- elif not re.match(r"^\d+\.\d+\.\d+$", definition.version):
+ elif not re.fullmatch(r"\d+\.\d+\.\d+", definition.version):
errors.append(
f"Workflow version {definition.version!r} is not valid "
f"semantic versioning (expected X.Y.Z)."
@@ -416,18 +416,57 @@ class RunState:
ID into a path so a malicious value cannot probe or read files
outside ``.specify/workflows/runs/<run_id>/``.
"""
- if not isinstance(run_id, str) or not cls._RUN_ID_PATTERN.match(run_id):
+ if not isinstance(run_id, str) or not cls._RUN_ID_PATTERN.fullmatch(run_id):
raise ValueError(
f"Invalid run_id {run_id!r}: must be alphanumeric with "
"hyphens/underscores only (and must start with an "
"alphanumeric character)."
)
+ @staticmethod
+ def _validate_installed_origin(
+ installed_workflow_id: str | None,
+ installed_registry_root: str | None,
+ ) -> None:
+ """Validate persisted installed-workflow ownership metadata."""
+ if installed_workflow_id is not None:
+ if not isinstance(installed_workflow_id, str):
+ raise ValueError(
+ "Invalid run state: 'installed_workflow_id' must be a "
+ f"string or null, got {type(installed_workflow_id).__name__}"
+ )
+ if not _ID_PATTERN.fullmatch(installed_workflow_id):
+ raise ValueError(
+ "Invalid run state: 'installed_workflow_id' must be a "
+ "lowercase alphanumeric workflow ID with hyphens"
+ )
+ if installed_registry_root is not None:
+ if not isinstance(installed_registry_root, str):
+ raise ValueError(
+ "Invalid run state: 'installed_registry_root' must be a "
+ f"string or null, got {type(installed_registry_root).__name__}"
+ )
+ if not installed_registry_root or not Path(
+ installed_registry_root
+ ).is_absolute():
+ raise ValueError(
+ "Invalid run state: 'installed_registry_root' must be "
+ "an absolute path or null"
+ )
+ if installed_workflow_id is None:
+ raise ValueError(
+ "Invalid run state: 'installed_registry_root' requires "
+ "'installed_workflow_id'"
+ )
+
def __init__(
self,
run_id: str | None = None,
workflow_id: str = "",
project_root: Path | None = None,
+ installed_workflow_id: str | None = None,
+ installed_registry_root: str | None = None,
+ installed_origin_tracked: bool = True,
) -> None:
# ``run_id is None`` (omitted) β†’ auto-generate. An explicit empty
# string is *not* the same as "omitted" and must be validated like
@@ -439,8 +478,22 @@ class RunState:
else:
self.run_id = run_id
self._validate_run_id(self.run_id)
+ self._validate_installed_origin(
+ installed_workflow_id, installed_registry_root
+ )
self.workflow_id = workflow_id
self.project_root = project_root or Path(".")
+ # Identifies the installed workflow (if any) this run was started
+ # from, and the project root that owns its registry β€” set by
+ # execute() when the source was resolved to an installed ID (see
+ # workflow_run's ownership mapping). None for a direct/non-installed
+ # YAML source. ``installed_origin_tracked`` distinguishes those
+ # explicit None values from legacy state files that predate both
+ # fields, allowing the CLI to conservatively infer same-project
+ # registry ownership before resuming.
+ self.installed_workflow_id = installed_workflow_id
+ self.installed_registry_root = installed_registry_root
+ self.installed_origin_tracked = installed_origin_tracked
self.status = RunStatus.CREATED
self.current_step_index = 0
self.current_step_id: str | None = None
@@ -503,6 +556,8 @@ class RunState:
state_data = {
"run_id": self.run_id,
"workflow_id": self.workflow_id,
+ "installed_workflow_id": self.installed_workflow_id,
+ "installed_registry_root": self.installed_registry_root,
"status": self.status.value,
"current_step_index": self.current_step_index,
"current_step_id": self.current_step_id,
@@ -554,11 +609,46 @@ class RunState:
with open(state_path, encoding="utf-8") as f:
state_data = json.load(f)
+ if not isinstance(state_data, dict):
+ raise ValueError("Invalid run state: expected a JSON object")
+ missing_fields = [
+ field
+ for field in ("run_id", "workflow_id", "status")
+ if field not in state_data
+ ]
+ if missing_fields:
+ raise ValueError(
+ "Invalid run state: missing required field(s): "
+ + ", ".join(missing_fields)
+ )
+
+ workflow_id = state_data["workflow_id"]
+ if not isinstance(workflow_id, str) or not _ID_PATTERN.fullmatch(
+ workflow_id
+ ):
+ raise ValueError(
+ "Invalid run state: 'workflow_id' must be a lowercase "
+ "alphanumeric workflow ID with hyphens"
+ )
+
+ has_installed_workflow_id = "installed_workflow_id" in state_data
+ has_installed_registry_root = "installed_registry_root" in state_data
+ if has_installed_workflow_id != has_installed_registry_root:
+ raise ValueError(
+ "Invalid run state: installed workflow origin fields must "
+ "either both be present or both be absent"
+ )
+
+ installed_workflow_id = state_data.get("installed_workflow_id")
+ installed_registry_root = state_data.get("installed_registry_root")
state = cls(
run_id=state_data["run_id"],
- workflow_id=state_data["workflow_id"],
+ workflow_id=workflow_id,
project_root=project_root,
+ installed_workflow_id=installed_workflow_id,
+ installed_registry_root=installed_registry_root,
+ installed_origin_tracked=has_installed_workflow_id,
)
state.status = RunStatus(state_data["status"])
state.current_step_index = state_data.get("current_step_index", 0)
@@ -571,7 +661,16 @@ class RunState:
if inputs_path.exists():
with open(inputs_path, encoding="utf-8") as f:
inputs_data = json.load(f)
- state.inputs = inputs_data.get("inputs", {})
+ if not isinstance(inputs_data, dict):
+ raise ValueError(
+ "Invalid run inputs: expected a JSON object"
+ )
+ inputs = inputs_data.get("inputs", {})
+ if not isinstance(inputs, dict):
+ raise ValueError(
+ "Invalid run inputs: 'inputs' must be a JSON object"
+ )
+ state.inputs = inputs
return state
@@ -654,6 +753,8 @@ class WorkflowEngine:
definition: WorkflowDefinition,
inputs: dict[str, Any] | None = None,
run_id: str | None = None,
+ installed_workflow_id: str | None = None,
+ installed_registry_root: Path | None = None,
) -> RunState:
"""Execute a workflow definition.
@@ -665,6 +766,12 @@ class WorkflowEngine:
User-provided input values.
run_id:
Optional run ID (uses SPECKIT_WORKFLOW_RUN_ID when set, otherwise auto-generated).
+ installed_workflow_id, installed_registry_root:
+ When the run was started from an installed workflow (as opposed
+ to a direct/non-installed YAML source), identifies it and its
+ owning registry root so a later ``resume`` can re-check the
+ registry's current disabled state before continuing β€” see
+ ``workflow_resume``.
Returns
-------
@@ -682,6 +789,12 @@ class WorkflowEngine:
run_id=effective_run_id,
workflow_id=definition.id,
project_root=self.project_root,
+ installed_workflow_id=installed_workflow_id,
+ installed_registry_root=(
+ str(installed_registry_root)
+ if installed_registry_root is not None
+ else None
+ ),
)
# Persist a copy of the workflow definition so resume can
diff --git a/tests/contract/test_bundle_cli.py b/tests/contract/test_bundle_cli.py
index df9c8dae1..db2bb0c94 100644
--- a/tests/contract/test_bundle_cli.py
+++ b/tests/contract/test_bundle_cli.py
@@ -6,6 +6,7 @@ contracts/cli-commands.md (offline, discovery-only refusal, not-a-project error)
"""
from __future__ import annotations
+import io
import json
from pathlib import Path
from unittest.mock import patch
@@ -63,6 +64,42 @@ def test_commands_outside_project_fail_with_guidance(tmp_path: Path, monkeypatch
assert "Spec Kit project" in result.output
+def test_remove_reports_clean_error_when_primitive_raises_raw_exception(
+ project: Path,
+):
+ """A raw exception from a primitive installer (e.g. an OSError from an
+ unreadable workflow registry surfacing through _WorkflowKindManager's
+ fail-closed construction) must not propagate uncaught through
+ `specify bundle remove` -- the command only catches BundlerError, so
+ without a conversion at the remove_bundle boundary this would exit
+ with an unhandled exception and empty/raw output instead of a clean,
+ actionable message, and no removal side effects should occur either."""
+ from specify_cli.bundler.models.manifest import BundleManifest
+ from specify_cli.bundler.models.records import load_records
+ from specify_cli.bundler.services.adapters import DefaultPrimitiveInstaller
+ from specify_cli.bundler.services.installer import install_bundle
+ from specify_cli.bundler.services.resolver import resolve_install_plan
+ from tests.bundler_helpers import FakeInstaller
+
+ manifest = BundleManifest.from_dict(valid_manifest_dict())
+ plan = resolve_install_plan(
+ manifest, speckit_version="0.11.2", active_integration="copilot"
+ )
+ install_bundle(project, plan, FakeInstaller(), manifest=manifest)
+
+ def boom(self, project_root, component):
+ raise OSError("workflow registry unreadable")
+
+ with pytest.MonkeyPatch.context() as mp:
+ mp.setattr(DefaultPrimitiveInstaller, "is_installed", boom)
+ result = runner.invoke(app, ["bundle", "remove", "demo-bundle"])
+
+ assert result.exit_code != 0
+ assert result.output.strip() != ""
+ assert result.exception is None or isinstance(result.exception, SystemExit)
+ assert {r.bundle_id for r in load_records(project)} == {"demo-bundle"}
+
+
def test_fail_writes_error_to_stderr_not_stdout(capsys):
"""_fail must write to stderr, not stdout: every bundle command routes errors
through it, and under --json the error would otherwise corrupt the JSON payload
@@ -432,25 +469,16 @@ def test_install_integration_override_cannot_bypass_clash_guard(project: Path):
# ===== Private GitHub release asset URL resolution =====
-class FakeBundleResponse:
+class FakeBundleResponse(io.BytesIO):
"""Minimal context-manager response stub for open_url fakes."""
def __init__(self, data: bytes, url: str = "https://api.github.com/repos/org/repo/releases/assets/99"):
- self._data = data
+ super().__init__(data)
self._url = url
- def read(self) -> bytes:
- return self._data
-
def geturl(self) -> str:
return self._url
- def __enter__(self):
- return self
-
- def __exit__(self, *_):
- return False
-
def _make_catalog_config(catalog_path: Path, project: Path) -> None:
"""Write a bundle-catalogs.yml pointing at *catalog_path* in *project*."""
diff --git a/tests/integration/test_bundler_install_flow.py b/tests/integration/test_bundler_install_flow.py
index bf066b660..655094168 100644
--- a/tests/integration/test_bundler_install_flow.py
+++ b/tests/integration/test_bundler_install_flow.py
@@ -11,7 +11,7 @@ import pytest
from specify_cli.bundler import BundlerError
from specify_cli.bundler.models.manifest import BundleManifest
-from specify_cli.bundler.models.records import load_records
+from specify_cli.bundler.models.records import load_records, records_path
from specify_cli.bundler.services.installer import install_bundle, remove_bundle
from specify_cli.bundler.services.resolver import resolve_install_plan
from tests.bundler_helpers import FakeInstaller, make_project, valid_manifest_dict
@@ -97,6 +97,212 @@ def test_remove_unknown_bundle_errors(tmp_path: Path):
remove_bundle(tmp_path, "ghost", FakeInstaller())
+def test_remove_converts_raw_installer_exception_to_bundler_error(tmp_path: Path):
+ """A raw exception from a primitive installer (e.g. an OSError from an
+ unreadable workflow registry surfacing through _WorkflowKindManager's
+ fail-closed construction) must not propagate uncaught out of
+ remove_bundle: install_bundle already converts any non-BundlerError
+ exception into a clean BundlerError, but remove_bundle had no such
+ conversion, so the CLI's `bundle remove` (which only catches
+ BundlerError) would let a raw exception through with no clean message
+ and no removal side effects should occur either."""
+ make_project(tmp_path)
+ manifest = BundleManifest.from_dict(valid_manifest_dict())
+ installer = FakeInstaller()
+ install_bundle(tmp_path, _plan(manifest), installer, manifest=manifest)
+
+ def boom(project_root, component):
+ raise OSError("workflow registry unreadable")
+
+ with pytest.MonkeyPatch.context() as mp:
+ mp.setattr(installer, "is_installed", boom)
+ with pytest.raises(BundlerError):
+ remove_bundle(tmp_path, "demo-bundle", installer)
+
+ # No removal side effects: the bundle record must still be present.
+ assert {r.bundle_id for r in load_records(tmp_path)} == {"demo-bundle"}
+
+
+def test_remove_partial_failure_message_reflects_partial_state(tmp_path: Path):
+ """A failure can occur after earlier components in the same bundle have
+ already been removed from disk. The bundle record is left unchanged
+ (save_records never runs on this path), so it still claims the bundle
+ fully installed -- but the message must not claim "No changes were
+ recorded" when components were, in fact, already removed."""
+ make_project(tmp_path)
+ manifest = BundleManifest.from_dict(valid_manifest_dict())
+ installer = FakeInstaller()
+ install_bundle(tmp_path, _plan(manifest), installer, manifest=manifest)
+
+ real_remove = installer.remove
+ calls = {"n": 0}
+
+ def remove_then_fail(project_root, component):
+ calls["n"] += 1
+ if calls["n"] == 1:
+ return real_remove(project_root, component)
+ raise OSError("disk full")
+
+ with pytest.MonkeyPatch.context() as mp:
+ mp.setattr(installer, "remove", remove_then_fail)
+ with pytest.raises(BundlerError) as exc_info:
+ remove_bundle(tmp_path, "demo-bundle", installer)
+
+ message = str(exc_info.value)
+ assert "no changes were recorded" not in message.lower()
+ assert {r.bundle_id for r in load_records(tmp_path)} == {"demo-bundle"}
+
+
+def test_remove_bundler_error_from_installer_after_partial_removal_reports_partial_state(
+ tmp_path: Path,
+):
+ """If the primitive installer itself raises BundlerError (not a raw/
+ unexpected exception) after an earlier component in the same bundle was
+ already removed, the surfaced message must still carry the same
+ partial-removal detail as the generic-exception path -- a bare
+ ``except BundlerError: raise`` would re-raise the installer's original
+ message verbatim with no mention that the project may now be partially
+ uninstalled."""
+ make_project(tmp_path)
+ manifest = BundleManifest.from_dict(valid_manifest_dict())
+ installer = FakeInstaller()
+ install_bundle(tmp_path, _plan(manifest), installer, manifest=manifest)
+
+ real_remove = installer.remove
+ calls = {"n": 0}
+
+ def remove_then_raise_bundler_error(project_root, component):
+ calls["n"] += 1
+ if calls["n"] == 1:
+ return real_remove(project_root, component)
+ raise BundlerError("kind manager refused removal")
+
+ with pytest.MonkeyPatch.context() as mp:
+ mp.setattr(installer, "remove", remove_then_raise_bundler_error)
+ with pytest.raises(BundlerError) as exc_info:
+ remove_bundle(tmp_path, "demo-bundle", installer)
+
+ message = str(exc_info.value)
+ assert "no changes were recorded" not in message.lower()
+ assert "kind manager refused removal" in message
+ assert "partially uninstalled" in message.lower()
+ assert {r.bundle_id for r in load_records(tmp_path)} == {"demo-bundle"}
+
+
+def test_remove_bundler_error_from_installer_with_zero_removed_reports_no_changes(
+ tmp_path: Path,
+):
+ """When the installer raises BundlerError before anything was actually
+ removed, the message should not misleadingly claim partial state."""
+ make_project(tmp_path)
+ manifest = BundleManifest.from_dict(valid_manifest_dict())
+ installer = FakeInstaller()
+ install_bundle(tmp_path, _plan(manifest), installer, manifest=manifest)
+
+ def boom(project_root, component):
+ raise BundlerError("kind manager unavailable")
+
+ with pytest.MonkeyPatch.context() as mp:
+ mp.setattr(installer, "is_installed", boom)
+ with pytest.raises(BundlerError) as exc_info:
+ remove_bundle(tmp_path, "demo-bundle", installer)
+
+ message = str(exc_info.value)
+ assert "no components were removed" in message.lower()
+ assert "no removal was attempted" in message.lower()
+ assert "partially uninstalled" not in message.lower()
+ assert "kind manager unavailable" in message
+ assert {r.bundle_id for r in load_records(tmp_path)} == {"demo-bundle"}
+
+
+def test_remove_zero_completed_removals_still_cautions_about_partial_changes(
+ tmp_path: Path,
+):
+ """`result.uninstalled` only records a component after its `remove()`
+ call returns successfully. If the very first `remove()` call itself
+ raises after already deleting some files, zero completed removals are
+ recorded even though the project may already be partially uninstalled --
+ the zero-count message must not claim "No components were removed" as
+ an unqualified fact; it must caution that the failing component may
+ have made partial changes before raising."""
+ make_project(tmp_path)
+ manifest = BundleManifest.from_dict(valid_manifest_dict())
+ installer = FakeInstaller()
+ install_bundle(tmp_path, _plan(manifest), installer, manifest=manifest)
+
+ def boom(project_root, component):
+ # Simulates a remove() that deletes some files before raising --
+ # from the caller's perspective this component was never recorded
+ # as completed, but disk state may already be partially changed.
+ raise OSError("disk full partway through removal")
+
+ with pytest.MonkeyPatch.context() as mp:
+ mp.setattr(installer, "remove", boom)
+ with pytest.raises(BundlerError) as exc_info:
+ remove_bundle(tmp_path, "demo-bundle", installer)
+
+ message = str(exc_info.value)
+ assert "no components were removed" in message.lower()
+ assert "partial" in message.lower()
+ assert "partially uninstalled" in message.lower()
+ assert {r.bundle_id for r in load_records(tmp_path)} == {"demo-bundle"}
+
+
+def test_remove_record_save_failure_reports_partial_state(tmp_path: Path):
+ make_project(tmp_path)
+ manifest = BundleManifest.from_dict(valid_manifest_dict())
+ installer = FakeInstaller()
+ install_bundle(tmp_path, _plan(manifest), installer, manifest=manifest)
+ record_file = records_path(tmp_path)
+ original_record = record_file.read_bytes()
+
+ def fail_dump(_data, handle, *_args, **_kwargs):
+ handle.write('{"partial":')
+ handle.flush()
+ raise OSError("disk full")
+
+ with pytest.MonkeyPatch.context() as mp:
+ mp.setattr(
+ "specify_cli.bundler.lib.yamlio.json.dump",
+ fail_dump,
+ )
+ with pytest.raises(BundlerError) as exc_info:
+ remove_bundle(tmp_path, "demo-bundle", installer)
+
+ message = str(exc_info.value)
+ assert "disk full" in message
+ assert "partially uninstalled" in message.lower()
+ assert installer.installed == set()
+ assert record_file.read_bytes() == original_record
+ assert {r.bundle_id for r in load_records(tmp_path)} == {"demo-bundle"}
+
+
+def test_remove_record_save_failure_without_remove_attempt_is_not_partial(
+ tmp_path: Path,
+):
+ make_project(tmp_path)
+ manifest = BundleManifest.from_dict(valid_manifest_dict())
+ installer = FakeInstaller()
+ install_bundle(tmp_path, _plan(manifest), installer, manifest=manifest)
+ installer.installed.clear()
+
+ def fail_save(*_args, **_kwargs):
+ raise OSError("disk full")
+
+ with pytest.MonkeyPatch.context() as mp:
+ mp.setattr(
+ "specify_cli.bundler.services.installer.save_records",
+ fail_save,
+ )
+ with pytest.raises(BundlerError) as exc_info:
+ remove_bundle(tmp_path, "demo-bundle", installer)
+
+ message = str(exc_info.value)
+ assert "no removal was attempted" in message.lower()
+ assert "partially uninstalled" not in message.lower()
+ assert {r.bundle_id for r in load_records(tmp_path)} == {"demo-bundle"}
+
+
def test_remove_reports_uninstalled_not_installed(tmp_path: Path):
make_project(tmp_path)
manifest = BundleManifest.from_dict(valid_manifest_dict())
@@ -128,7 +334,7 @@ def test_remove_counts_only_components_actually_removed(tmp_path: Path):
assert len(result.uninstalled) == 3
assert (gone.kind, gone.id) not in installer.remove_calls
- assert gone in result.skipped
+ assert gone not in result.skipped
make_project(tmp_path)
manifest = BundleManifest.from_dict(valid_manifest_dict())
installer = FakeInstaller()
diff --git a/tests/test_github_http.py b/tests/test_github_http.py
index a03fe9186..3f6ca8e53 100644
--- a/tests/test_github_http.py
+++ b/tests/test_github_http.py
@@ -152,6 +152,44 @@ class TestResolveGitHubReleaseAssetApiUrl:
)
assert result is None
+ def test_metadata_lookup_is_bounded_and_redirect_validated(self):
+ """Release metadata reads stay bounded and use the caller's policy."""
+ captured = {}
+
+ class OversizedResponse:
+ def read(self, amount=None):
+ captured["read_amount"] = amount
+ return b"x" * amount
+
+ def __enter__(self):
+ return self
+
+ def __exit__(self, *args):
+ return False
+
+ def redirect_validator(old_url, new_url):
+ return None
+
+ def fake_open(
+ url,
+ timeout=None,
+ extra_headers=None,
+ redirect_validator=None,
+ ):
+ captured["redirect_validator"] = redirect_validator
+ return OversizedResponse()
+
+ result = resolve_github_release_asset_api_url(
+ "https://github.com/org/repo/releases/download/v1/pack.zip",
+ fake_open,
+ redirect_validator=redirect_validator,
+ max_metadata_bytes=8,
+ )
+
+ assert result is None
+ assert captured["read_amount"] == 9
+ assert captured["redirect_validator"] is redirect_validator
+
def test_tag_with_special_characters_is_url_encoded(self):
"""Tags with reserved characters (e.g. '/') are encoded in the API URL."""
captured_urls = []
diff --git a/tests/test_presets.py b/tests/test_presets.py
index 12dbf90af..8208a416e 100644
--- a/tests/test_presets.py
+++ b/tests/test_presets.py
@@ -5016,26 +5016,13 @@ class TestPresetAddFromUrlResolution:
captured_urls = []
- class FakeResponse:
- def __init__(self, data):
- self._data = data
-
- def read(self):
- return self._data
-
- def __enter__(self):
- return self
-
- def __exit__(self, *a):
- return False
-
def fake_open_url(url, timeout=None, extra_headers=None, redirect_validator=None):
captured_urls.append((url, extra_headers))
if "releases/tags/" in url:
- return FakeResponse(json.dumps({
+ return io.BytesIO(json.dumps({
"assets": [{"name": "preset.zip", "url": "https://api.github.com/repos/org/repo/releases/assets/42"}]
}).encode())
- return FakeResponse(zip_bytes)
+ return io.BytesIO(zip_bytes)
runner = CliRunner()
with patch.object(Path, "cwd", return_value=project_dir), \
@@ -5074,22 +5061,9 @@ class TestPresetAddFromUrlResolution:
captured_urls = []
- class FakeResponse:
- def __init__(self, data):
- self._data = data
-
- def read(self):
- return self._data
-
- def __enter__(self):
- return self
-
- def __exit__(self, *a):
- return False
-
def fake_open_url(url, timeout=None, extra_headers=None, redirect_validator=None):
captured_urls.append((url, extra_headers))
- return FakeResponse(zip_bytes)
+ return io.BytesIO(zip_bytes)
runner = CliRunner()
with patch.object(Path, "cwd", return_value=project_dir), \
@@ -5131,26 +5105,13 @@ class TestPresetAddFromUrlResolution:
captured_urls = []
- class FakeResponse:
- def __init__(self, data):
- self._data = data
-
- def read(self):
- return self._data
-
- def __enter__(self):
- return self
-
- def __exit__(self, *a):
- return False
-
def fake_open_url(url, timeout=None, extra_headers=None, redirect_validator=None):
captured_urls.append((url, extra_headers))
if "releases/tags/" in url:
- return FakeResponse(json.dumps({
+ return io.BytesIO(json.dumps({
"assets": [{"name": "preset.zip", "url": "https://ghes.example/api/v3/repos/org/repo/releases/assets/42"}]
}).encode())
- return FakeResponse(zip_bytes)
+ return io.BytesIO(zip_bytes)
runner = CliRunner()
with patch.object(Path, "cwd", return_value=project_dir), \
diff --git a/tests/test_workflows.py b/tests/test_workflows.py
index 81aec96d3..d5a6d2697 100644
--- a/tests/test_workflows.py
+++ b/tests/test_workflows.py
@@ -15,6 +15,7 @@ from __future__ import annotations
import json
import os
import shutil
+import stat
import sys
import tempfile
from pathlib import Path
@@ -2964,6 +2965,21 @@ steps:
errors = validate_workflow(definition)
assert any("lowercase alphanumeric" in e for e in errors)
+ def test_workflow_id_with_trailing_newline_is_invalid(self):
+ from specify_cli.workflows.engine import WorkflowDefinition, validate_workflow
+
+ definition = WorkflowDefinition.from_string("""
+workflow:
+ id: "valid\\n"
+ name: "Test"
+ version: "1.0.0"
+steps:
+ - id: step-one
+ command: speckit.specify
+""")
+ errors = validate_workflow(definition)
+ assert any("lowercase alphanumeric" in e for e in errors)
+
def test_non_string_workflow_id_reports_error(self):
from specify_cli.workflows.engine import WorkflowDefinition, validate_workflow
@@ -3009,6 +3025,21 @@ steps:
errors = validate_workflow(definition)
assert any("workflow.version" in e and "quote" in e for e in errors)
+ def test_version_with_trailing_newline_is_invalid(self):
+ from specify_cli.workflows.engine import WorkflowDefinition, validate_workflow
+
+ definition = WorkflowDefinition.from_string("""
+workflow:
+ id: "test"
+ name: "Test"
+ version: "1.0.0\\n"
+steps:
+ - id: step-one
+ command: speckit.specify
+""")
+ errors = validate_workflow(definition)
+ assert any("semantic version" in e for e in errors)
+
def test_non_string_step_id_reports_error(self):
from specify_cli.workflows.engine import WorkflowDefinition, validate_workflow
@@ -3345,6 +3376,38 @@ steps:
assert state.step_results["step-one"]["output"]["command"] == "speckit.specify"
assert state.step_results["step-one"]["output"]["input"]["args"] == "login"
+ def test_execute_rejects_invalid_origin_before_creating_run_state(
+ self, project_dir
+ ):
+ from specify_cli.workflows.engine import WorkflowDefinition, WorkflowEngine
+
+ definition = WorkflowDefinition.from_string("""
+schema_version: "1.0"
+workflow:
+ id: "simple"
+ name: "Simple"
+ version: "1.0.0"
+steps: []
+""")
+ engine = WorkflowEngine(project_dir)
+
+ with pytest.raises(ValueError, match="installed_registry_root"):
+ engine.execute(
+ definition,
+ run_id="invalid-origin",
+ installed_workflow_id="simple",
+ installed_registry_root=Path("relative-owner"),
+ )
+
+ run_dir = (
+ project_dir
+ / ".specify"
+ / "workflows"
+ / "runs"
+ / "invalid-origin"
+ )
+ assert not run_dir.exists()
+
def test_execute_with_gate_pauses(self, project_dir):
from specify_cli.workflows.engine import WorkflowEngine, WorkflowDefinition
from specify_cli.workflows.base import RunStatus
@@ -4754,6 +4817,39 @@ class TestRunState:
with pytest.raises(FileNotFoundError):
RunState.load("nonexistent", project_dir)
+ @pytest.mark.parametrize(
+ ("installed_workflow_id", "installed_registry_root"),
+ [
+ ("", None),
+ ("gated-wf\n", None),
+ ("gated-wf", "relative-owner"),
+ ],
+ )
+ def test_init_rejects_invalid_installed_origin(
+ self, installed_workflow_id, installed_registry_root
+ ):
+ from specify_cli.workflows.engine import RunState
+
+ with pytest.raises(ValueError, match="Invalid run state"):
+ RunState(
+ run_id="test-run",
+ workflow_id="test-workflow",
+ installed_workflow_id=installed_workflow_id,
+ installed_registry_root=installed_registry_root,
+ )
+
+ def test_init_rejects_registry_root_without_workflow_id(
+ self, project_dir
+ ):
+ from specify_cli.workflows.engine import RunState
+
+ with pytest.raises(ValueError, match="requires"):
+ RunState(
+ run_id="test-run",
+ workflow_id="test-workflow",
+ installed_registry_root=str(project_dir),
+ )
+
@pytest.mark.parametrize(
"malicious_run_id",
[
@@ -4824,6 +4920,7 @@ class TestRunState:
"../escape", # parent-directory traversal
"foo/bar", # embedded path separator
".hidden", # leading non-alphanumeric
+ "valid\n", # regex end-anchor bypass
"", # empty / degenerate
],
)
@@ -4936,6 +5033,32 @@ class TestWorkflowRegistry:
registry.remove("test-wf")
assert not registry.is_installed("test-wf")
+ @pytest.mark.parametrize("error_type", [OSError, TypeError, ValueError])
+ def test_remove_rolls_back_in_memory_on_save_failure(
+ self, project_dir, monkeypatch, error_type
+ ):
+ """A save() failure during remove() must not leave the in-memory registry
+ out of sync with the (unchanged) file on disk, mirroring add()'s rollback."""
+ from specify_cli.workflows.catalog import WorkflowRegistry
+ import specify_cli.workflows.catalog as catalog_mod
+
+ registry = WorkflowRegistry(project_dir)
+ registry.add("test-wf", {"name": "Test", "version": "1.0.0"})
+
+ def boom(*args, **kwargs):
+ raise error_type("save failed")
+
+ monkeypatch.setattr(catalog_mod.json, "dump", boom)
+ with pytest.raises(error_type):
+ registry.remove("test-wf")
+ monkeypatch.undo()
+
+ # In-memory state must still show the entry (rolled back), matching
+ # the untouched file on disk.
+ assert registry.is_installed("test-wf")
+ fresh = WorkflowRegistry(project_dir)
+ assert fresh.is_installed("test-wf")
+
def test_list(self, project_dir):
from specify_cli.workflows.catalog import WorkflowRegistry
@@ -4966,32 +5089,83 @@ class TestWorkflowRegistry:
registry2 = WorkflowRegistry(project_dir)
assert registry2.is_installed("test-wf")
- @pytest.mark.parametrize("bad_content", ["[]", '{"schema_version": "1.0"}'])
- def test_load_tolerates_misshaped_registry(self, project_dir, bad_content):
- """A JSON-valid but mis-shaped registry file must not crash every method.
+ def test_load_read_oserror_refuses_to_save_over_existing_data(self, project_dir, monkeypatch):
+ """A transient read failure (e.g. temporarily unreadable file) must not be
+ treated the same as a corrupted/missing registry: constructing a registry
+ on top of it -- and thus any query a caller makes before ever calling
+ save() -- must fail closed instead of silently reporting an empty
+ registry that a caller could then act on and overwrite."""
+ from specify_cli.workflows.catalog import WorkflowRegistry
+ import builtins
+
+ registry1 = WorkflowRegistry(project_dir)
+ registry1.add("test-wf", {"name": "Test", "version": "1.0.0"})
+ registry_path = registry1.registry_path
+ real_open = builtins.open
- A list root, or a dict lacking a 'workflows' mapping, previously made
- is_installed/get/list/remove/add raise TypeError/KeyError. Mirrors the
- shape guard StepRegistry._load already has.
- """
+ def _raising_open(file, mode="r", *args, **kwargs):
+ if Path(file) == registry_path and "r" in mode:
+ raise OSError("simulated read failure")
+ return real_open(file, mode, *args, **kwargs)
+
+ monkeypatch.setattr(builtins, "open", _raising_open)
+ with pytest.raises(OSError):
+ WorkflowRegistry(project_dir)
+ # The original entry must survive on disk untouched.
+ data = json.loads(registry_path.read_text(encoding="utf-8"))
+ assert "test-wf" in data["workflows"]
+
+ def test_load_read_oserror_fails_closed_not_silently_empty(self, project_dir, monkeypatch):
+ """Root cause: a registry that failed to read must never let a query
+ method (is_installed/get/list) report as if nothing were installed --
+ a caller (e.g. bundled workflow install) that only checks
+ is_installed() before writing a file would otherwise overwrite real
+ data on a transient read failure, long before any save() call could
+ catch it. The failure must surface at construction, before any query
+ or side effect is possible."""
from specify_cli.workflows.catalog import WorkflowRegistry
+ import builtins
- reg_path = project_dir / ".specify" / "workflows" / "workflow-registry.json"
- reg_path.parent.mkdir(parents=True, exist_ok=True)
- reg_path.write_text(bad_content, encoding="utf-8")
+ registry1 = WorkflowRegistry(project_dir)
+ registry1.add("test-wf", {"name": "Test", "version": "1.0.0"})
+ registry_path = registry1.registry_path
+ real_open = builtins.open
- registry = WorkflowRegistry(project_dir)
- assert registry.data == {
- "schema_version": WorkflowRegistry.SCHEMA_VERSION,
- "workflows": {},
- }
- # None of these should raise on the recovered-default shape.
- assert registry.is_installed("x") is False
- assert registry.get("x") is None
- assert registry.list() == {} # list() always returns a dict
- registry.remove("x")
- registry.add("x", {"name": "X"})
- assert registry.is_installed("x")
+ def _raising_open(file, mode="r", *args, **kwargs):
+ if Path(file) == registry_path and "r" in mode:
+ raise OSError("simulated read failure")
+ return real_open(file, mode, *args, **kwargs)
+
+ monkeypatch.setattr(builtins, "open", _raising_open)
+ with pytest.raises(OSError):
+ WorkflowRegistry(project_dir)
+
+ @pytest.mark.skipif(not hasattr(os, "symlink"), reason="symlinks are unavailable")
+ def test_load_symlinked_workflows_dir_fails_closed_not_silently_empty(
+ self, project_dir
+ ):
+ """A symlinked .specify/workflows is the same fail-open hazard as a
+ read OSError: silently reporting an empty registry lets a read-only
+ caller (e.g. the bundler's remove path) conclude a workflow isn't
+ installed, skip removing it, and then delete the bundle record --
+ leaving the workflow untracked but still on disk. Raise here too,
+ exactly like the unreadable-file case, so callers cannot act on
+ fabricated empty state."""
+ from specify_cli.workflows.catalog import WorkflowRegistry
+ import json as _json
+
+ outside = project_dir.parent / "outside-workflows"
+ outside.mkdir(parents=True, exist_ok=True)
+ (outside / "workflow-registry.json").write_text(
+ _json.dumps({"schema_version": "1.0", "workflows": {"evil": {}}}),
+ encoding="utf-8",
+ )
+ workflows_link = project_dir / ".specify" / "workflows"
+ workflows_link.rmdir()
+ workflows_link.symlink_to(outside, target_is_directory=True)
+
+ with pytest.raises(OSError):
+ WorkflowRegistry(project_dir)
# ===== Workflow Catalog Tests =====
@@ -6120,6 +6294,143 @@ class TestWorkflowRemoveGuard:
assert workflow_path.read_text(encoding="utf-8") == "not a directory"
assert WorkflowRegistry(project_dir).is_installed("test-wf")
+ @pytest.mark.parametrize("error_type", [OSError, TypeError, ValueError])
+ def test_remove_registry_save_failure_preserves_files_and_registry(
+ self, project_dir, monkeypatch, error_type
+ ):
+ """If persisting the registry removal fails, the workflow's files must
+ not have already been deleted: the CLI must not delete files before the
+ registry successfully records the removal, and it must fail cleanly."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowRegistry
+
+ registry = WorkflowRegistry(project_dir)
+ registry.add("test-wf", {"name": "Test", "version": "1.0.0"})
+ workflow_dir = project_dir / ".specify" / "workflows" / "test-wf"
+ workflow_dir.mkdir(parents=True, exist_ok=True)
+ (workflow_dir / "workflow.yml").write_text("keep-me", encoding="utf-8")
+
+ def boom(self):
+ raise error_type("save failed")
+
+ monkeypatch.chdir(project_dir)
+ with pytest.MonkeyPatch.context() as mp:
+ mp.setattr(WorkflowRegistry, "save", boom)
+ result = CliRunner().invoke(app, ["workflow", "remove", "test-wf"])
+
+ assert result.exit_code != 0
+ assert result.exception is None or isinstance(result.exception, SystemExit)
+ assert result.output.strip() != ""
+ # Files must survive a registry-save failure.
+ assert (workflow_dir / "workflow.yml").read_text(encoding="utf-8") == "keep-me"
+ # The on-disk registry must still claim the workflow installed.
+ assert WorkflowRegistry(project_dir).is_installed("test-wf")
+ # The directory must be restored to its exact original location, with
+ # no leftover staging directory from the stage/restore-on-failure
+ # sequence.
+ entries = [
+ p.name
+ for p in (project_dir / ".specify" / "workflows").iterdir()
+ if p.name != "workflow-registry.json"
+ ]
+ assert entries == ["test-wf"]
+
+ def test_remove_staged_cleanup_failure_reports_warning_not_error(
+ self, project_dir, monkeypatch
+ ):
+ """The directory is staged (atomically renamed out of
+ .specify/workflows/<id>) *before* the registry write, and the actual
+ deletion of the staged directory only happens *after* the registry
+ has already durably recorded the removal. If that final deletion
+ fails, the registry write already succeeded and must stand -- an
+ "Error: Failed to remove..." message at that point would contradict
+ the registry, which is exactly the incoherent state this staging
+ order exists to prevent. It must be reported as a cleanup warning,
+ and the command must still succeed."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowRegistry
+
+ registry = WorkflowRegistry(project_dir)
+ registry.add("test-wf", {"name": "Test", "version": "1.0.0"})
+ workflow_dir = project_dir / ".specify" / "workflows" / "test-wf"
+ workflow_dir.mkdir(parents=True, exist_ok=True)
+ (workflow_dir / "workflow.yml").write_text("keep-me", encoding="utf-8")
+
+ def boom(*args, **kwargs):
+ raise OSError("permission denied")
+
+ monkeypatch.chdir(project_dir)
+ with pytest.MonkeyPatch.context() as mp:
+ mp.setattr("shutil.rmtree", boom)
+ result = CliRunner().invoke(app, ["workflow", "remove", "test-wf"])
+
+ assert result.exit_code == 0
+ assert "Warning" in result.output
+ # The registry write already committed -- it must stand.
+ assert not WorkflowRegistry(project_dir).is_installed("test-wf")
+ # The original install path is gone (staged away before the registry
+ # write ever ran); only a leftover staged directory remains, never
+ # at the original path the registry/CLI would treat as installed.
+ assert not workflow_dir.exists()
+ leftovers = [
+ p
+ for p in (project_dir / ".specify" / "workflows").iterdir()
+ if p.name != "workflow-registry.json"
+ ]
+ assert len(leftovers) == 1
+ assert (leftovers[0] / "workflow.yml").read_text(encoding="utf-8") == "keep-me"
+
+ def test_remove_stage_restore_failure_escapes_rich_markup(
+ self, temp_dir, monkeypatch
+ ):
+ """When the registry write fails (already rolled back in-memory by
+ WorkflowRegistry.remove()) and the attempt to rename the staged
+ directory back to its original location also fails, both the
+ restore exception and the registry-update exception interpolated
+ into these warning/error messages must be escaped like every other
+ error path here."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowRegistry
+
+ project_dir = temp_dir / "weird[project]"
+ project_dir.mkdir()
+ (project_dir / ".specify").mkdir()
+ (project_dir / ".specify" / "workflows").mkdir()
+
+ registry = WorkflowRegistry(project_dir)
+ registry.add("test-wf", {"name": "Test", "version": "1.0.0"})
+ workflow_dir = project_dir / ".specify" / "workflows" / "test-wf"
+ workflow_dir.mkdir(parents=True, exist_ok=True)
+ (workflow_dir / "workflow.yml").write_text("keep-me", encoding="utf-8")
+
+ def save_boom(self):
+ raise OSError("[reg] disk full")
+
+ real_rename = os.rename
+ rename_calls = {"n": 0}
+
+ def rename_boom(src, dst):
+ rename_calls["n"] += 1
+ if rename_calls["n"] == 1:
+ # Allow the initial stage-out rename to succeed so the
+ # restore-back rename (the second call) is what fails.
+ return real_rename(src, dst)
+ raise OSError("[stage] permission denied")
+
+ monkeypatch.chdir(project_dir)
+ with pytest.MonkeyPatch.context() as mp:
+ mp.setattr(WorkflowRegistry, "save", save_boom)
+ mp.setattr(os, "rename", rename_boom)
+ result = CliRunner().invoke(app, ["workflow", "remove", "test-wf"])
+
+ assert result.exit_code != 0
+ assert result.exception is None or isinstance(result.exception, SystemExit)
+ output_compact = "".join(result.output.split())
+ assert "[stage]permissiondenied" in output_compact
+ assert "[reg]diskfull" in output_compact
class TestWorkflowAddSymlinkGuard:
def test_add_malformed_ipv6_url_exits_cleanly(self, temp_dir, monkeypatch):
@@ -6172,6 +6483,34 @@ class TestWorkflowAddSymlinkGuard:
assert result.exit_code != 0
assert "symlinked .specify/workflows" in result.output
+ def test_add_escapes_rich_markup_in_validation_errors(self, temp_dir, monkeypatch):
+ """User-controlled YAML values in validation errors must not be parsed as Rich markup."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+
+ (temp_dir / ".specify" / "workflows").mkdir(parents=True)
+ src = temp_dir / "incoming.yml"
+ src.write_text(
+ """
+schema_version: "1.0"
+workflow:
+ id: "markup-wf"
+ name: "Markup"
+ version: "[bold]bad[/bold]"
+
+steps:
+ - id: step-one
+ command: speckit.specify
+""",
+ encoding="utf-8",
+ )
+
+ monkeypatch.chdir(temp_dir)
+ result = CliRunner().invoke(app, ["workflow", "add", str(src)])
+
+ assert result.exit_code != 0
+ assert "[bold]bad[/bold]" in result.output
+
@pytest.mark.skipif(not hasattr(os, "symlink"), reason="symlinks are unavailable")
def test_add_refuses_symlinked_id_dir(self, temp_dir, monkeypatch, sample_workflow_yaml):
"""A symlinked <id> install dir must not let a copy escape the project root."""
@@ -6352,6 +6691,71 @@ class TestWorkflowStepAddCLI:
assert result.exit_code != 0
assert "Refusing to use symlinked step directory" in result.output
+ def test_add_rejects_oversized_step_response(self, project_dir, monkeypatch):
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows import _commands as wf_commands
+ from specify_cli.workflows.catalog import StepCatalog
+ from specify_cli.authentication import http as auth_http
+
+ monkeypatch.chdir(project_dir)
+ monkeypatch.setattr(wf_commands, "_MAX_WORKFLOW_YAML_BYTES", 100)
+ monkeypatch.setattr(
+ StepCatalog,
+ "get_step_info",
+ lambda self, step_id: {
+ "id": step_id,
+ "name": "Test Step",
+ "url": "https://example.com/step.yml",
+ "init_url": "https://example.com/__init__.py",
+ "_install_allowed": True,
+ },
+ )
+
+ class _FakeResponse:
+ def __init__(self, url):
+ self.url = url
+ self.body = b"x" * 500
+ self.offset = 0
+
+ def __enter__(self):
+ return self
+
+ def __exit__(self, exc_type, exc, tb):
+ return False
+
+ def getheader(self, name):
+ return None
+
+ def geturl(self):
+ return self.url
+
+ def read(self, size=-1):
+ if size < 0:
+ size = len(self.body) - self.offset
+ chunk = self.body[self.offset : self.offset + size]
+ self.offset += len(chunk)
+ return chunk
+
+ monkeypatch.setattr(
+ auth_http,
+ "open_url",
+ lambda url, timeout=30, redirect_validator=None: _FakeResponse(url),
+ )
+
+ result = CliRunner().invoke(
+ app, ["workflow", "step", "add", "my-step"]
+ )
+
+ assert result.exit_code != 0
+ assert (
+ "responseexceedsthe100-byteworkflowsizelimit"
+ in "".join(result.output.split())
+ )
+ assert not (
+ project_dir / ".specify" / "workflows" / "steps" / "my-step"
+ ).exists()
+
def test_add_rejects_non_string_extra_files_key(self, project_dir, monkeypatch):
from typer.testing import CliRunner
from specify_cli import app
@@ -6382,7 +6786,10 @@ class TestWorkflowStepAddCLI:
def __exit__(self, exc_type, exc, tb):
return False
- def read(self):
+ def read(self, size=-1):
+ if getattr(self, "_read", False):
+ return b""
+ self._read = True
if self.url.endswith("/step.yml"):
return b"step:\n type_key: my-step\n"
return b""
@@ -6390,7 +6797,7 @@ class TestWorkflowStepAddCLI:
def geturl(self):
return self.url
- def _fake_open_url(url, timeout=30):
+ def _fake_open_url(url, timeout=30, redirect_validator=None):
return _FakeResponse(url)
monkeypatch.setattr(StepCatalog, "get_step_info", _fake_get_step_info)
@@ -6441,7 +6848,10 @@ class TestWorkflowStepAddCLI:
def __exit__(self, exc_type, exc, tb):
return False
- def read(self):
+ def read(self, size=-1):
+ if getattr(self, "_read", False):
+ return b""
+ self._read = True
if self.url.endswith("/step.yml"):
return b"step:\n type_key: my-step\n"
return b""
@@ -6449,7 +6859,7 @@ class TestWorkflowStepAddCLI:
def geturl(self):
return self.url
- def _fake_open_url(url, timeout=30):
+ def _fake_open_url(url, timeout=30, redirect_validator=None):
return _FakeResponse(url)
monkeypatch.setattr(StepCatalog, "get_step_info", _fake_get_step_info)
@@ -6489,7 +6899,10 @@ class TestWorkflowStepAddCLI:
def __exit__(self, exc_type, exc, tb):
return False
- def read(self):
+ def read(self, size=-1):
+ if getattr(self, "_read", False):
+ return b""
+ self._read = True
if self.url.endswith("/step.yml"):
return b"step:\n type_key: my-step\n"
return b""
@@ -6497,7 +6910,7 @@ class TestWorkflowStepAddCLI:
def geturl(self):
return self.url
- def _fake_open_url(url, timeout=30):
+ def _fake_open_url(url, timeout=30, redirect_validator=None):
return _FakeResponse(url)
monkeypatch.setattr(StepCatalog, "get_step_info", _fake_get_step_info)
@@ -6806,8 +7219,16 @@ steps:
self._data = data
self._url = url or "https://api.github.com/repos/org/repo/releases/assets/42"
- def read(self):
- return self._data
+ def read(self, amt=None):
+ if not hasattr(self, "_pos"):
+ self._pos = 0
+ if amt is None:
+ chunk = self._data[self._pos :]
+ self._pos = len(self._data)
+ return chunk
+ chunk = self._data[self._pos : self._pos + amt]
+ self._pos += len(chunk)
+ return chunk
def geturl(self):
return self._url
@@ -6818,8 +7239,10 @@ steps:
def __exit__(self, *a):
return False
- def fake_open_url(url, timeout=None, extra_headers=None):
- captured_urls.append((url, extra_headers, timeout))
+ def fake_open_url(url, timeout=None, extra_headers=None, redirect_validator=None):
+ captured_urls.append(
+ (url, extra_headers, timeout, redirect_validator)
+ )
if "releases/tags/" in url:
return FakeResponse(json.dumps({
"assets": [{"name": "workflow.yml", "url": "https://api.github.com/repos/org/repo/releases/assets/42"}]
@@ -6837,11 +7260,20 @@ steps:
assert result.exit_code == 0, result.output
assert "Test Workflow" in result.output
# First call resolves the release tag with timeout=30
- tag_calls = [(url, h, t) for url, h, t in captured_urls if "releases/tags/" in url]
+ tag_calls = [
+ (url, headers, timeout, validator)
+ for url, headers, timeout, validator in captured_urls
+ if "releases/tags/" in url
+ ]
assert len(tag_calls) == 1
assert tag_calls[0][2] == 30 # timeout matches download timeout
+ assert tag_calls[0][3] is not None
# Second call downloads from the resolved asset URL with octet-stream
- asset_calls = [(url, h, t) for url, h, t in captured_urls if "releases/assets/" in url]
+ asset_calls = [
+ (url, headers, timeout, validator)
+ for url, headers, timeout, validator in captured_urls
+ if "releases/assets/" in url
+ ]
assert len(asset_calls) >= 1
assert asset_calls[0][1] == {"Accept": "application/octet-stream"}
@@ -6858,8 +7290,16 @@ steps:
self._data = data
self._url = url or "https://api.github.com/repos/org/repo/releases/assets/42"
- def read(self):
- return self._data
+ def read(self, amt=None):
+ if not hasattr(self, "_pos"):
+ self._pos = 0
+ if amt is None:
+ chunk = self._data[self._pos :]
+ self._pos = len(self._data)
+ return chunk
+ chunk = self._data[self._pos : self._pos + amt]
+ self._pos += len(chunk)
+ return chunk
def geturl(self):
return self._url
@@ -6870,7 +7310,7 @@ steps:
def __exit__(self, *a):
return False
- def fake_open_url(url, timeout=None, extra_headers=None):
+ def fake_open_url(url, timeout=None, extra_headers=None, redirect_validator=None):
captured_urls.append((url, extra_headers))
return FakeResponse(self.VALID_WORKFLOW_YAML.encode())
@@ -6901,8 +7341,16 @@ steps:
self._data = data
self._url = url or "https://api.github.com/repos/org/repo/releases/assets/55"
- def read(self):
- return self._data
+ def read(self, amt=None):
+ if not hasattr(self, "_pos"):
+ self._pos = 0
+ if amt is None:
+ chunk = self._data[self._pos :]
+ self._pos = len(self._data)
+ return chunk
+ chunk = self._data[self._pos : self._pos + amt]
+ self._pos += len(chunk)
+ return chunk
def geturl(self):
return self._url
@@ -6913,8 +7361,8 @@ steps:
def __exit__(self, *a):
return False
- def fake_open_url(url, timeout=None, extra_headers=None):
- captured_urls.append((url, extra_headers))
+ def fake_open_url(url, timeout=None, extra_headers=None, redirect_validator=None):
+ captured_urls.append((url, extra_headers, redirect_validator))
if "releases/tags/" in url:
return FakeResponse(json.dumps({
"assets": [{"name": "workflow.yml", "url": "https://api.github.com/repos/org/repo/releases/assets/55"}]
@@ -6950,11 +7398,20 @@ steps:
assert result.exit_code == 0, result.output
# Should resolve via releases/tags API
- tag_calls = [url for url, _ in captured_urls if "releases/tags/" in url]
+ tag_calls = [
+ (url, validator)
+ for url, _, validator in captured_urls
+ if "releases/tags/" in url
+ ]
assert len(tag_calls) == 1
- assert "releases/tags/v2.0" in tag_calls[0]
+ assert "releases/tags/v2.0" in tag_calls[0][0]
+ assert tag_calls[0][1] is not None
# Should download from resolved asset URL with octet-stream
- asset_calls = [(url, h) for url, h in captured_urls if "releases/assets/" in url]
+ asset_calls = [
+ (url, headers)
+ for url, headers, _ in captured_urls
+ if "releases/assets/" in url
+ ]
assert len(asset_calls) >= 1
assert asset_calls[0][1] == {"Accept": "application/octet-stream"}
@@ -6977,8 +7434,16 @@ steps:
self._data = data
self._url = url or "https://ghes.example/api/v3/repos/org/repo/releases/assets/42"
- def read(self):
- return self._data
+ def read(self, amt=None):
+ if not hasattr(self, "_pos"):
+ self._pos = 0
+ if amt is None:
+ chunk = self._data[self._pos :]
+ self._pos = len(self._data)
+ return chunk
+ chunk = self._data[self._pos : self._pos + amt]
+ self._pos += len(chunk)
+ return chunk
def geturl(self):
return self._url
@@ -6989,7 +7454,7 @@ steps:
def __exit__(self, *a):
return False
- def fake_open_url(url, timeout=None, extra_headers=None):
+ def fake_open_url(url, timeout=None, extra_headers=None, redirect_validator=None):
captured_urls.append((url, extra_headers))
if "releases/tags/" in url:
return FakeResponse(json.dumps({
@@ -7032,8 +7497,16 @@ steps:
self._data = data
self._url = url or "https://ghes.example/api/v3/repos/org/repo/releases/assets/55"
- def read(self):
- return self._data
+ def read(self, amt=None):
+ if not hasattr(self, "_pos"):
+ self._pos = 0
+ if amt is None:
+ chunk = self._data[self._pos :]
+ self._pos = len(self._data)
+ return chunk
+ chunk = self._data[self._pos : self._pos + amt]
+ self._pos += len(chunk)
+ return chunk
def geturl(self):
return self._url
@@ -7057,7 +7530,7 @@ steps:
run: "echo hello"
"""
- def fake_open_url(url, timeout=None, extra_headers=None):
+ def fake_open_url(url, timeout=None, extra_headers=None, redirect_validator=None):
captured_urls.append((url, extra_headers))
if "releases/tags/" in url:
return FakeResponse(json.dumps({
@@ -7461,3 +7934,4429 @@ class TestWorkflowAddNonStringScalars:
assert result.exit_code == 1
assert result.exception is None or isinstance(result.exception, SystemExit)
assert "Step ID" in result.output
+
+
+class TestWorkflowCliAlignment:
+ """CLI alignment with extension/preset commands (#2342)."""
+
+ WORKFLOW_YAML = """
+schema_version: "1.0"
+workflow:
+ id: "align-wf"
+ name: "Align Workflow"
+ version: "{version}"
+ description: "CLI alignment test workflow"
+steps:
+ - id: step-one
+ type: shell
+ run: "echo hello"
+"""
+
+ def _write_workflow_dir(self, base, version="1.0.0"):
+ d = base / "wf-src"
+ d.mkdir(parents=True, exist_ok=True)
+ (d / "workflow.yml").write_text(
+ self.WORKFLOW_YAML.format(version=version), encoding="utf-8"
+ )
+ return d
+
+ def _install_dev(self, runner, app, project_dir):
+ src = self._write_workflow_dir(project_dir)
+ result = runner.invoke(app, ["workflow", "add", str(src), "--dev"])
+ assert result.exit_code == 0, result.output
+ return src
+
+ # -- add --dev -----------------------------------------------------
+
+ def test_add_dev_directory_installs(self, project_dir, monkeypatch):
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ runner = CliRunner()
+ self._install_dev(runner, app, project_dir)
+ assert WorkflowRegistry(project_dir).is_installed("align-wf")
+
+ def test_add_dev_yaml_file_installs(self, project_dir, monkeypatch):
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ src = self._write_workflow_dir(project_dir)
+ runner = CliRunner()
+ result = runner.invoke(app, ["workflow", "add", str(src / "workflow.yml"), "--dev"])
+ assert result.exit_code == 0, result.output
+ assert WorkflowRegistry(project_dir).is_installed("align-wf")
+
+ def test_add_dev_missing_path_errors(self, project_dir, monkeypatch):
+ from typer.testing import CliRunner
+ from specify_cli import app
+
+ monkeypatch.chdir(project_dir)
+ runner = CliRunner()
+ result = runner.invoke(app, ["workflow", "add", str(project_dir / "missing"), "--dev"])
+ assert result.exit_code != 0
+ assert "--dev" in result.output
+
+ def test_add_dev_dir_without_workflow_yml_errors(self, project_dir, monkeypatch):
+ from typer.testing import CliRunner
+ from specify_cli import app
+
+ monkeypatch.chdir(project_dir)
+ empty = project_dir / "empty-src"
+ empty.mkdir()
+ runner = CliRunner()
+ result = runner.invoke(app, ["workflow", "add", str(empty), "--dev"])
+ assert result.exit_code != 0
+ assert "No workflow.yml found" in result.output
+
+ def test_add_local_dir_without_workflow_yml_errors(self, project_dir, monkeypatch):
+ """Same as the --dev case, but for the plain local-path fallback (no --dev)."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+
+ monkeypatch.chdir(project_dir)
+ empty = project_dir / "empty-src-[bracket]"
+ empty.mkdir()
+ runner = CliRunner()
+ result = runner.invoke(app, ["workflow", "add", str(empty)])
+ assert result.exit_code != 0
+ assert "No workflow.yml found" in result.output
+ assert "[bracket]" in result.output
+
+ def test_add_local_dir_with_workflow_yml_directory_errors_cleanly(self, project_dir, monkeypatch):
+ """Same as the --dev case, but for the plain local-path fallback (no --dev):
+ a directory named workflow.yml must not reach open() and leak IsADirectoryError."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+
+ monkeypatch.chdir(project_dir)
+ src_dir = project_dir / "local-wf"
+ (src_dir / "workflow.yml").mkdir(parents=True)
+ runner = CliRunner()
+ result = runner.invoke(app, ["workflow", "add", str(src_dir)])
+ assert result.exit_code != 0
+ assert result.exception is None or isinstance(result.exception, SystemExit)
+ assert "No workflow.yml found" in result.output
+
+ def test_add_yaml_parse_error_escapes_rich_markup(self, project_dir, monkeypatch):
+ """A YAML syntax error can quote the offending line verbatim; brackets in it must not be Rich markup."""
+ from unittest.mock import patch
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.engine import WorkflowDefinition
+
+ monkeypatch.chdir(project_dir)
+ bad = project_dir / "bad.yml"
+ bad.write_text("workflow:\n id: wf\n", encoding="utf-8")
+ runner = CliRunner()
+ with patch.object(
+ WorkflowDefinition,
+ "from_string",
+ side_effect=ValueError('bad snippet: "New [Feature]"'),
+ ):
+ result = runner.invoke(app, ["workflow", "add", str(bad)])
+ assert result.exit_code != 0
+ assert 'bad snippet: "New [Feature]"' in result.output
+
+ # -- add --from ----------------------------------------------------
+
+ class _FakeResponse:
+ def __init__(self, data, url="https://example.com/workflow.yml", headers=None):
+ self._data = data
+ self._url = url
+ self._pos = 0
+ self._headers = headers or {}
+
+ def read(self, amt=None):
+ if amt is None:
+ chunk = self._data[self._pos :]
+ self._pos = len(self._data)
+ return chunk
+ chunk = self._data[self._pos : self._pos + amt]
+ self._pos += len(chunk)
+ return chunk
+
+ def getheader(self, name, default=None):
+ return self._headers.get(name, default)
+
+ def geturl(self):
+ return self._url
+
+ def __enter__(self):
+ return self
+
+ def __exit__(self, *a):
+ return False
+
+ @pytest.mark.parametrize("mode", ["dev", "local", "from"])
+ def test_reinstall_preserves_disabled_state(
+ self, project_dir, monkeypatch, mode
+ ):
+ from unittest.mock import patch
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ runner = CliRunner()
+ src = self._install_dev(runner, app, project_dir)
+ result = runner.invoke(app, ["workflow", "disable", "align-wf"])
+ assert result.exit_code == 0, result.output
+
+ if mode == "dev":
+ result = runner.invoke(
+ app, ["workflow", "add", str(src), "--dev"]
+ )
+ elif mode == "local":
+ result = runner.invoke(app, ["workflow", "add", str(src)])
+ else:
+ data = self.WORKFLOW_YAML.format(version="2.0.0").encode()
+ with patch(
+ "specify_cli.authentication.http.open_url",
+ side_effect=lambda url, timeout=None, extra_headers=None,
+ redirect_validator=None: self._FakeResponse(data, url),
+ ):
+ result = runner.invoke(
+ app,
+ [
+ "workflow", "add", "align-wf",
+ "--from", "https://example.com/workflow.yml",
+ ],
+ input="y\n",
+ )
+
+ assert result.exit_code == 0, result.output
+ assert WorkflowRegistry(project_dir).get("align-wf")["enabled"] is False
+
+ def test_add_from_url_rejects_oversized_content_length(self, project_dir, monkeypatch):
+ """A --from download must not trust an advertised Content-Length
+ alone by reading the whole body first -- it must reject a response
+ that declares a size over the workflow YAML limit before reading
+ the (potentially huge) body into memory at all."""
+ from unittest.mock import patch
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows import _commands as wf_commands
+
+ monkeypatch.chdir(project_dir)
+ monkeypatch.setattr(wf_commands, "_MAX_WORKFLOW_YAML_BYTES", 100)
+ small_body = b"id: align-wf\n" # small actual body; Content-Length lies
+ runner = CliRunner()
+ with patch(
+ "specify_cli.authentication.http.open_url",
+ side_effect=lambda url, timeout=None, extra_headers=None, redirect_validator=None: self._FakeResponse(
+ small_body, url, headers={"Content-Length": "1000"}
+ ),
+ ):
+ result = runner.invoke(
+ app,
+ ["workflow", "add", "align-wf", "--from", "https://example.com/workflow.yml"],
+ input="y\n",
+ )
+ assert result.exit_code != 0
+ assert result.exception is None or isinstance(result.exception, SystemExit)
+ assert "exceedingthe100-byteworkflowsizelimit" in "".join(result.output.split())
+
+ def test_add_from_url_requires_default_deny_confirmation(
+ self, project_dir, monkeypatch
+ ):
+ from unittest.mock import patch
+
+ from typer.testing import CliRunner
+ from specify_cli import app
+
+ monkeypatch.chdir(project_dir)
+ with patch(
+ "specify_cli.authentication.http.open_url",
+ side_effect=AssertionError("download should not start"),
+ ):
+ result = CliRunner().invoke(
+ app,
+ [
+ "workflow",
+ "add",
+ "align-wf",
+ "--from",
+ "https://example.com/workflow.yml",
+ ],
+ input="n\n",
+ )
+
+ assert result.exit_code == 0, result.output
+ assert "Untrusted Source" in result.output
+ assert "Cancelled" in result.output
+
+ def test_add_from_url_rejects_oversized_streamed_body_without_content_length(
+ self, project_dir, monkeypatch
+ ):
+ """A chunked/no-Content-Length response must still be capped by
+ actually counting streamed bytes -- a malicious or misbehaving
+ server cannot bypass the limit merely by omitting or lying about
+ Content-Length."""
+ from unittest.mock import patch
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows import _commands as wf_commands
+
+ monkeypatch.chdir(project_dir)
+ monkeypatch.setattr(wf_commands, "_MAX_WORKFLOW_YAML_BYTES", 100)
+ oversized_body = b"x" * 500 # no Content-Length header at all
+ runner = CliRunner()
+ with patch(
+ "specify_cli.authentication.http.open_url",
+ side_effect=lambda url, timeout=None, extra_headers=None, redirect_validator=None: self._FakeResponse(
+ oversized_body, url
+ ),
+ ):
+ result = runner.invoke(
+ app,
+ ["workflow", "add", "align-wf", "--from", "https://example.com/workflow.yml"],
+ input="y\n",
+ )
+ assert result.exit_code != 0
+ assert result.exception is None or isinstance(result.exception, SystemExit)
+ assert "exceedsthe100-byteworkflowsizelimit" in "".join(result.output.split())
+
+ def test_add_from_url_oversized_streamed_body_leaves_no_temp_file(
+ self, project_dir, monkeypatch, tmp_path
+ ):
+ """A rejected --from download (oversized streamed body, no
+ Content-Length) must not leave the 0-byte NamedTemporaryFile behind:
+ the file is created on disk as soon as it is opened (delete=False),
+ before any bytes are written, so a failure inside the size-limit
+ check must still clean it up rather than merely erroring out."""
+ import tempfile as tempfile_mod
+ from unittest.mock import patch
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows import _commands as wf_commands
+
+ monkeypatch.chdir(project_dir)
+ monkeypatch.setattr(wf_commands, "_MAX_WORKFLOW_YAML_BYTES", 100)
+ scratch_tmp = tmp_path / "scratch-tmp"
+ scratch_tmp.mkdir()
+ monkeypatch.setattr(tempfile_mod, "tempdir", str(scratch_tmp))
+ oversized_body = b"x" * 500 # no Content-Length header at all
+ runner = CliRunner()
+ with patch(
+ "specify_cli.authentication.http.open_url",
+ side_effect=lambda url, timeout=None, extra_headers=None, redirect_validator=None: self._FakeResponse(
+ oversized_body, url
+ ),
+ ):
+ result = runner.invoke(
+ app,
+ ["workflow", "add", "align-wf", "--from", "https://example.com/workflow.yml"],
+ input="y\n",
+ )
+ assert result.exit_code != 0
+ assert "exceedsthe100-byteworkflowsizelimit" in "".join(result.output.split())
+ leaked = list(scratch_tmp.glob("*.yml"))
+ assert leaked == [], f"leaked temp files: {leaked}"
+
+ def test_add_from_url_oversized_content_length_leaves_no_temp_file(
+ self, project_dir, monkeypatch, tmp_path
+ ):
+ """Same guarantee for the fail-fast Content-Length rejection path:
+ it must not even leave a 0-byte temp file behind."""
+ import tempfile as tempfile_mod
+ from unittest.mock import patch
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows import _commands as wf_commands
+
+ monkeypatch.chdir(project_dir)
+ monkeypatch.setattr(wf_commands, "_MAX_WORKFLOW_YAML_BYTES", 100)
+ scratch_tmp = tmp_path / "scratch-tmp"
+ scratch_tmp.mkdir()
+ monkeypatch.setattr(tempfile_mod, "tempdir", str(scratch_tmp))
+ small_body = b"id: align-wf\n" # small actual body; Content-Length lies
+ runner = CliRunner()
+ with patch(
+ "specify_cli.authentication.http.open_url",
+ side_effect=lambda url, timeout=None, extra_headers=None, redirect_validator=None: self._FakeResponse(
+ small_body, url, headers={"Content-Length": "1000"}
+ ),
+ ):
+ result = runner.invoke(
+ app,
+ ["workflow", "add", "align-wf", "--from", "https://example.com/workflow.yml"],
+ input="y\n",
+ )
+ assert result.exit_code != 0
+ assert "exceedingthe100-byteworkflowsizelimit" in "".join(result.output.split())
+ leaked = list(scratch_tmp.glob("*.yml"))
+ assert leaked == [], f"leaked temp files: {leaked}"
+
+ def test_add_from_url_download_failure_cleanup_error_preserves_original_error(
+ self, project_dir, monkeypatch, tmp_path
+ ):
+ """The --from download-failure branch's `tmp_path.unlink(missing_ok=
+ True)` can itself raise (e.g. read-only tempdir) before the clean
+ "Failed to download workflow" message is ever printed, replacing it
+ with a raw unhandled OSError. A cleanup failure there must be
+ guarded exactly like the later post-install finally cleanup: warn
+ about the cleanup failure, then still preserve/report the original
+ download error via a clean typer.Exit, never a raw traceback."""
+ import tempfile as tempfile_mod
+ from unittest.mock import patch
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows import _commands as wf_commands
+ from specify_cli.workflows.catalog import WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ monkeypatch.setattr(wf_commands, "_MAX_WORKFLOW_YAML_BYTES", 100)
+ scratch_tmp = tmp_path / "scratch-tmp"
+ scratch_tmp.mkdir()
+ monkeypatch.setattr(tempfile_mod, "tempdir", str(scratch_tmp))
+ oversized_body = b"x" * 500 # no Content-Length header at all
+ runner = CliRunner()
+
+ real_unlink = Path.unlink
+
+ def unlink_boom(self_path, *args, **kwargs):
+ if self_path.suffix == ".yml" and self_path.parent == scratch_tmp:
+ raise OSError("cleanup denied")
+ return real_unlink(self_path, *args, **kwargs)
+
+ with patch(
+ "specify_cli.authentication.http.open_url",
+ side_effect=lambda url, timeout=None, extra_headers=None, redirect_validator=None: self._FakeResponse(
+ oversized_body, url
+ ),
+ ), pytest.MonkeyPatch.context() as mp:
+ mp.setattr(Path, "unlink", unlink_boom)
+ result = runner.invoke(
+ app,
+ ["workflow", "add", "align-wf", "--from", "https://example.com/workflow.yml"],
+ input="y\n",
+ )
+
+ assert result.exit_code != 0
+ assert result.exception is None or isinstance(result.exception, SystemExit)
+ # Original download error remains present.
+ assert "exceedsthe100-byteworkflowsizelimit" in "".join(result.output.split())
+ # Cleanup failure is reported too, not silently swallowed / crashing.
+ assert "cleanup denied" in result.output
+ assert "Warning" in result.output
+ assert not WorkflowRegistry(project_dir).is_installed("align-wf")
+
+ def test_add_from_url_installs(self, project_dir, monkeypatch):
+ from unittest.mock import patch
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ data = self.WORKFLOW_YAML.format(version="1.0.0").encode()
+ runner = CliRunner()
+ with patch(
+ "specify_cli.authentication.http.open_url",
+ side_effect=lambda url, timeout=None, extra_headers=None, redirect_validator=None: self._FakeResponse(data, url),
+ ):
+ result = runner.invoke(
+ app,
+ ["workflow", "add", "align-wf", "--from", "https://example.com/workflow.yml"],
+ input="y\n",
+ )
+ assert result.exit_code == 0, result.output
+ assert WorkflowRegistry(project_dir).is_installed("align-wf")
+
+ def test_add_from_url_temp_cleanup_failure_after_success_still_exits_zero(
+ self, project_dir, monkeypatch
+ ):
+ """An OSError while deleting the --from download's temp file after
+ _validate_and_install_local() has already committed the file and
+ registry entry must not surface as an unhandled failure for an
+ install that already succeeded -- it must be a warning, exit 0."""
+ from unittest.mock import patch
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ data = self.WORKFLOW_YAML.format(version="1.0.0").encode()
+ runner = CliRunner()
+
+ import tempfile
+
+ real_unlink = Path.unlink
+
+ def unlink_boom(self_path, *args, **kwargs):
+ if self_path.suffix == ".yml" and self_path.parent == Path(tempfile.gettempdir()):
+ raise OSError("permission denied")
+ return real_unlink(self_path, *args, **kwargs)
+
+ with patch(
+ "specify_cli.authentication.http.open_url",
+ side_effect=lambda url, timeout=None, extra_headers=None, redirect_validator=None: self._FakeResponse(data, url),
+ ), pytest.MonkeyPatch.context() as mp:
+ mp.setattr(Path, "unlink", unlink_boom)
+ result = runner.invoke(
+ app,
+ ["workflow", "add", "align-wf", "--from", "https://example.com/workflow.yml"],
+ input="y\n",
+ )
+
+ assert result.exit_code == 0, result.output
+ assert "Warning" in result.output
+ assert "permissiondenied" in "".join(result.output.split())
+ assert WorkflowRegistry(project_dir).is_installed("align-wf")
+
+ def test_add_from_url_id_mismatch_errors(self, project_dir, monkeypatch):
+ from unittest.mock import patch
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ data = self.WORKFLOW_YAML.format(version="1.0.0").encode()
+ runner = CliRunner()
+ with patch(
+ "specify_cli.authentication.http.open_url",
+ side_effect=lambda url, timeout=None, extra_headers=None, redirect_validator=None: self._FakeResponse(data, url),
+ ):
+ result = runner.invoke(
+ app,
+ ["workflow", "add", "other-id", "--from", "https://example.com/workflow.yml"],
+ input="y\n",
+ )
+ assert result.exit_code != 0
+ assert "does not match" in result.output
+ assert not WorkflowRegistry(project_dir).is_installed("align-wf")
+
+ def test_add_from_empty_url_rejected_not_catalog_fallback(self, project_dir, monkeypatch):
+ """--from "" must fail URL validation, not silently install from the catalog."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ runner = CliRunner()
+ result = runner.invoke(app, ["workflow", "add", "align-wf", "--from", ""])
+ assert result.exit_code != 0
+ assert "HTTPS" in result.output
+ assert not WorkflowRegistry(project_dir).is_installed("align-wf")
+
+ def test_add_from_url_non_https_redirect_escapes_rich_markup(self, project_dir, monkeypatch):
+ """A redirect to a non-HTTPS IPv6 literal (legally bracketed) must not be parsed as Rich markup."""
+ from unittest.mock import patch
+ from typer.testing import CliRunner
+ from specify_cli import app
+
+ monkeypatch.chdir(project_dir)
+ redirected_url = "http://[2001:db8::1]/workflow.yml"
+ runner = CliRunner()
+ with patch(
+ "specify_cli.authentication.http.open_url",
+ side_effect=lambda url, timeout=None, extra_headers=None, redirect_validator=None: self._FakeResponse(b"", redirected_url),
+ ):
+ result = runner.invoke(
+ app,
+ ["workflow", "add", "align-wf", "--from", "https://example.com/workflow.yml"],
+ input="y\n",
+ )
+ assert result.exit_code != 0
+ assert redirected_url in result.output
+
+ def test_add_from_rejects_invalid_source_id_without_fetch(self, project_dir, monkeypatch):
+ """--from with a non-workflow-id source (URL, path, uppercase) fails before any network fetch."""
+ from unittest.mock import patch
+ from typer.testing import CliRunner
+ from specify_cli import app
+
+ monkeypatch.chdir(project_dir)
+ calls: list[str] = []
+
+ def _fake_open(url, timeout=None, extra_headers=None, redirect_validator=None):
+ calls.append(url)
+ raise AssertionError(f"network fetch attempted: {url}")
+
+ runner = CliRunner()
+ with patch("specify_cli.authentication.http.open_url", side_effect=_fake_open):
+ for bad_source in ("https://x/y.yml", "./local.yml", "BadCase"):
+ result = runner.invoke(
+ app,
+ ["workflow", "add", bad_source, "--from", "https://example.com/workflow.yml"],
+ )
+ assert result.exit_code != 0
+ assert "Invalid workflow ID" in result.output
+ assert calls == []
+
+ # -- search --author -----------------------------------------------
+
+ def test_search_author_filters(self, project_dir, monkeypatch):
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowCatalog
+
+ monkeypatch.chdir(project_dir)
+ workflows = {
+ "wf-a": {"name": "Workflow A", "version": "1.0.0", "description": "", "author": "alice"},
+ "wf-b": {"name": "Workflow B", "version": "1.0.0", "description": "", "author": "bob"},
+ }
+ monkeypatch.setattr(
+ WorkflowCatalog,
+ "_get_merged_workflows",
+ lambda self, force_refresh=False: {k: dict(v) for k, v in workflows.items()},
+ )
+ runner = CliRunner()
+ result = runner.invoke(app, ["workflow", "search", "--author", "Alice"])
+ assert result.exit_code == 0, result.output
+ assert "wf-a" in result.output
+ assert "wf-b" not in result.output
+
+ def test_search_escapes_rich_markup_in_catalog_fields(self, project_dir, monkeypatch):
+ """Catalog-derived name/description/tags must not be parsed as Rich markup."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowCatalog
+
+ monkeypatch.chdir(project_dir)
+ workflows = {
+ "wf-a": {
+ "name": "Bracket [Search]",
+ "version": "1.0.0",
+ "description": "desc [with] brackets",
+ "tags": ["tag[1]", "tag2"],
+ },
+ }
+ monkeypatch.setattr(
+ WorkflowCatalog,
+ "_get_merged_workflows",
+ lambda self, force_refresh=False: {k: dict(v) for k, v in workflows.items()},
+ )
+ runner = CliRunner()
+ result = runner.invoke(app, ["workflow", "search"])
+ assert result.exit_code == 0, result.output
+ assert "Bracket [Search]" in result.output
+ assert "desc [with] brackets" in result.output
+ assert "tag[1]" in result.output
+
+ # -- update ----------------------------------------------------------
+
+ def test_update_no_workflows_installed(self, project_dir, monkeypatch):
+ from typer.testing import CliRunner
+ from specify_cli import app
+
+ monkeypatch.chdir(project_dir)
+ runner = CliRunner()
+ result = runner.invoke(app, ["workflow", "update"])
+ assert result.exit_code == 0, result.output
+ assert "No workflows installed" in result.output
+
+ def test_update_not_installed_errors(self, project_dir, monkeypatch):
+ from typer.testing import CliRunner
+ from specify_cli import app
+
+ monkeypatch.chdir(project_dir)
+ runner = CliRunner()
+ result = runner.invoke(app, ["workflow", "update", "ghost"])
+ assert result.exit_code != 0
+ assert "not installed" in result.output
+
+ def test_update_skips_non_catalog_sources(self, project_dir, monkeypatch):
+ from typer.testing import CliRunner
+ from specify_cli import app
+
+ monkeypatch.chdir(project_dir)
+ runner = CliRunner()
+ self._install_dev(runner, app, project_dir)
+ result = runner.invoke(app, ["workflow", "update"])
+ assert result.exit_code == 0, result.output
+ assert "re-add to update" in result.output
+ # Every target was skipped β€” must not claim everything is up to date.
+ assert "No workflows were eligible for update" in result.output
+ assert "up to date!" not in result.output
+
+ def test_update_skip_message_accurate_for_bundled_source(self, project_dir, monkeypatch):
+ """A workflow registered with source "bundled" (e.g. the speckit
+ workflow installed by `specify init`) was never installed from a
+ local path or URL; the skip message must not claim otherwise."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ registry = WorkflowRegistry(project_dir)
+ registry.add(
+ "speckit",
+ {"name": "Speckit", "version": "1.0.0", "source": "bundled"},
+ )
+ runner = CliRunner()
+ result = runner.invoke(app, ["workflow", "update"])
+ assert result.exit_code == 0, result.output
+ assert "local path or URL" not in result.output
+ assert "re-add to update" in result.output
+
+ def test_registry_add_rolls_back_memory_on_save_failure(self, project_dir, monkeypatch):
+ from specify_cli.workflows.catalog import WorkflowRegistry
+
+ registry = WorkflowRegistry(project_dir)
+ registry.add("align-wf", {"version": "1.0.0", "source": "catalog"})
+
+ def boom():
+ raise OSError("disk full")
+
+ monkeypatch.setattr(registry, "save", boom)
+ with pytest.raises(OSError):
+ registry.add("align-wf", {"version": "2.0.0", "source": "catalog"})
+ assert registry.get("align-wf")["version"] == "1.0.0"
+
+ with pytest.raises(OSError):
+ registry.add("other-wf", {"version": "1.0.0", "source": "catalog"})
+ assert registry.get("other-wf") is None
+
+ @pytest.mark.parametrize("error_type", [TypeError, ValueError])
+ def test_registry_add_rolls_back_memory_on_serialization_failure(
+ self, project_dir, monkeypatch, error_type
+ ):
+ from specify_cli.workflows.catalog import WorkflowRegistry
+
+ registry = WorkflowRegistry(project_dir)
+ registry.add("align-wf", {"version": "1.0.0", "source": "catalog"})
+
+ def boom():
+ raise error_type("not JSON serializable")
+
+ monkeypatch.setattr(registry, "save", boom)
+ with pytest.raises(error_type):
+ registry.add("align-wf", {"version": "2.0.0", "source": "catalog"})
+ assert registry.get("align-wf")["version"] == "1.0.0"
+
+ with pytest.raises(error_type):
+ registry.add("other-wf", {"version": "1.0.0", "source": "catalog"})
+ assert registry.get("other-wf") is None
+
+ def test_registry_add_survives_non_dict_existing_entry(self, project_dir):
+ from specify_cli.workflows.catalog import WorkflowRegistry
+
+ registry = WorkflowRegistry(project_dir)
+ registry.data["workflows"]["align-wf"] = "corrupted"
+ registry.add("align-wf", {"version": "1.0.0", "source": "catalog"})
+ assert registry.get("align-wf")["version"] == "1.0.0"
+
+ @pytest.mark.parametrize(
+ "contents",
+ [
+ "not json",
+ "[]",
+ '{"schema_version": "1.0"}',
+ '{"schema_version": "1.0", "workflows": "broken"}',
+ ],
+ )
+ def test_registry_load_rejects_corrupt_contents(
+ self, project_dir, contents
+ ):
+ from specify_cli.workflows.catalog import WorkflowRegistry
+
+ registry = WorkflowRegistry(project_dir)
+ registry.workflows_dir.mkdir(parents=True, exist_ok=True)
+ registry.registry_path.write_text(contents, encoding="utf-8")
+
+ with pytest.raises(OSError, match="corrupt"):
+ WorkflowRegistry(project_dir)
+
+ assert registry.registry_path.read_text(encoding="utf-8") == contents
+
+ def test_registry_save_refuses_symlinked_parent(self, project_dir, tmp_path):
+ """Construction now fails closed on a symlinked .specify just like
+ an unreadable registry file: a symlinked parent must never be
+ silently tolerated up to save() -- it must raise immediately."""
+ from specify_cli.workflows.catalog import WorkflowRegistry
+
+ outside = tmp_path / "outside-specify"
+ outside.mkdir()
+ specify_dir = project_dir / ".specify"
+ if specify_dir.exists():
+ shutil.rmtree(specify_dir)
+ specify_dir.symlink_to(outside)
+ with pytest.raises(OSError, match="symlink"):
+ WorkflowRegistry(project_dir)
+ assert not (outside / "workflows").exists()
+
+ @pytest.mark.skipif(sys.platform == "win32", reason="chmod mode bits not reliable on Windows")
+ def test_registry_save_preserves_existing_file_mode(self, project_dir):
+ """A registry shared as 0640/0644 must keep that mode after a save,
+ not be silently replaced by mkstemp's 0600 default -- otherwise
+ every add/remove locks other project users out of a previously
+ shared registry file."""
+ from specify_cli.workflows.catalog import WorkflowRegistry
+
+ registry = WorkflowRegistry(project_dir)
+ registry.add("first-wf", {"name": "First"})
+ registry.registry_path.chmod(0o644)
+
+ registry.add("second-wf", {"name": "Second"})
+
+ mode = stat.S_IMODE(registry.registry_path.stat().st_mode)
+ assert mode == 0o644, f"expected 0644, got {oct(mode)}"
+
+ @pytest.mark.skipif(not hasattr(os, "fchown"), reason="os.fchown is unavailable")
+ def test_registry_save_preserves_existing_owner_group(
+ self, project_dir, monkeypatch
+ ):
+ from specify_cli.workflows.catalog import WorkflowRegistry
+ import specify_cli.workflows.catalog as catalog_mod
+
+ registry = WorkflowRegistry(project_dir)
+ registry.add("first-wf", {"name": "First"})
+ existing = registry.registry_path.stat()
+ calls: list[tuple[os.stat_result, int, int]] = []
+
+ monkeypatch.setattr(
+ catalog_mod.os,
+ "fchown",
+ lambda fd, uid, gid: calls.append((os.fstat(fd), uid, gid)),
+ )
+ registry.add("second-wf", {"name": "Second"})
+
+ assert len(calls) == 1
+ temp_stat, uid, gid = calls[0]
+ assert stat.S_ISREG(temp_stat.st_mode)
+ assert uid == existing.st_uid
+ assert gid == existing.st_gid
+
+ @pytest.mark.skipif(sys.platform == "win32", reason="chmod mode bits not reliable on Windows")
+ def test_registry_save_on_new_registry_uses_secure_default_mode(self, project_dir):
+ """A brand-new registry file (no prior mode to preserve) should keep
+ mkstemp's secure 0600 default rather than something more permissive."""
+ from specify_cli.workflows.catalog import WorkflowRegistry
+
+ registry = WorkflowRegistry(project_dir)
+ registry.add("first-wf", {"name": "First"})
+
+ mode = stat.S_IMODE(registry.registry_path.stat().st_mode)
+ assert mode == 0o600, f"expected 0600, got {oct(mode)}"
+
+ @pytest.mark.skipif(not hasattr(os, "symlink"), reason="symlinks are unavailable")
+ def test_registry_save_rejects_swapped_temp_without_touching_target(
+ self, project_dir, monkeypatch
+ ):
+ from specify_cli.workflows.catalog import WorkflowRegistry
+ import specify_cli.workflows.catalog as catalog_mod
+
+ registry = WorkflowRegistry(project_dir)
+ registry.add("first-wf", {"name": "First"})
+ registry.registry_path.chmod(0o640)
+
+ victim = project_dir / "victim.txt"
+ victim.write_text("untouched", encoding="utf-8")
+ victim.chmod(0o600)
+
+ tmp_path = None
+ real_mkstemp = catalog_mod.tempfile.mkstemp
+ real_dump = catalog_mod.json.dump
+
+ def tracking_mkstemp(*args, **kwargs):
+ nonlocal tmp_path
+ fd, name = real_mkstemp(*args, **kwargs)
+ tmp_path = Path(name)
+ return fd, name
+
+ def swap_after_dump(*args, **kwargs):
+ result = real_dump(*args, **kwargs)
+ assert tmp_path is not None
+ tmp_path.unlink()
+ tmp_path.symlink_to(victim)
+ return result
+
+ monkeypatch.setattr(catalog_mod.tempfile, "mkstemp", tracking_mkstemp)
+ monkeypatch.setattr(catalog_mod.json, "dump", swap_after_dump)
+
+ with pytest.raises(OSError):
+ registry.add("second-wf", {"name": "Second"})
+
+ assert victim.read_text(encoding="utf-8") == "untouched"
+ if sys.platform != "win32":
+ assert stat.S_IMODE(victim.stat().st_mode) == 0o600
+ assert not registry.registry_path.is_symlink()
+ assert WorkflowRegistry(project_dir).is_installed("first-wf")
+
+ def test_add_dev_dir_with_workflow_yml_directory_errors_cleanly(self, project_dir, monkeypatch):
+ from typer.testing import CliRunner
+ from specify_cli import app
+
+ monkeypatch.chdir(project_dir)
+ dev_dir = project_dir / "dev-wf"
+ (dev_dir / "workflow.yml").mkdir(parents=True)
+ runner = CliRunner()
+ result = runner.invoke(app, ["workflow", "add", "--dev", str(dev_dir)])
+ assert result.exit_code != 0
+ assert result.exception is None or isinstance(result.exception, SystemExit)
+ assert "No workflow.yml found" in result.output
+
+ @pytest.mark.parametrize("mode", ["dev", "local", "from_url"])
+ def test_add_save_failure_leaves_no_orphan_directory(self, project_dir, monkeypatch, mode):
+ """A registry.add() save failure during a fresh install must not leave
+ an orphaned workflow directory on disk, and must fail with a clean
+ escaped message instead of a raw OSError traceback. Shared by --dev,
+ the plain local-path fallback, and --from since all three funnel
+ through _validate_and_install_local's single install choke point."""
+ import contextlib
+ from unittest.mock import patch
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ runner = CliRunner()
+
+ def boom(self):
+ raise OSError("disk full")
+
+ if mode == "from_url":
+ data = self.WORKFLOW_YAML.format(version="1.0.0").encode()
+ args = ["workflow", "add", "align-wf", "--from", "https://example.com/workflow.yml"]
+ url_patch = patch(
+ "specify_cli.authentication.http.open_url",
+ side_effect=lambda url, timeout=None, extra_headers=None, redirect_validator=None: self._FakeResponse(data, url),
+ )
+ else:
+ src = self._write_workflow_dir(project_dir)
+ args = ["workflow", "add", str(src)] + (["--dev"] if mode == "dev" else [])
+ url_patch = contextlib.nullcontext()
+
+ with url_patch, pytest.MonkeyPatch.context() as mp:
+ mp.setattr(WorkflowRegistry, "save", boom)
+ result = runner.invoke(
+ app, args, input="y\n" if mode == "from_url" else None
+ )
+
+ assert result.exit_code != 0
+ assert result.exception is None or isinstance(result.exception, SystemExit)
+ assert result.output.strip() != ""
+ dest_dir = project_dir / ".specify" / "workflows" / "align-wf"
+ assert not dest_dir.exists()
+ assert not WorkflowRegistry(project_dir).is_installed("align-wf")
+
+ @pytest.mark.parametrize("mode", ["dev", "catalog"])
+ def test_add_non_json_description_rolls_back_transaction(
+ self, project_dir, monkeypatch, mode
+ ):
+ import contextlib
+ from unittest.mock import patch
+
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowCatalog, WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ data = self.WORKFLOW_YAML.format(version="1.0.0").replace(
+ 'description: "CLI alignment test workflow"',
+ "description: 2026-01-02",
+ ).encode()
+
+ if mode == "dev":
+ source = project_dir / "dated-description"
+ source.mkdir()
+ (source / "workflow.yml").write_bytes(data)
+ args = ["workflow", "add", str(source), "--dev"]
+ download = contextlib.nullcontext()
+ else:
+ monkeypatch.setattr(
+ WorkflowCatalog,
+ "get_workflow_info",
+ lambda self, wid: {
+ "id": wid,
+ "name": "Align Workflow",
+ "version": "1.0.0",
+ "url": "https://example.com/workflow.yml",
+ "_install_allowed": True,
+ "_catalog_name": "test-catalog",
+ },
+ )
+ args = ["workflow", "add", "align-wf"]
+ download = patch(
+ "specify_cli.authentication.http.open_url",
+ side_effect=lambda url, timeout=None, extra_headers=None,
+ redirect_validator=None: self._FakeResponse(data, url),
+ )
+
+ with download:
+ result = CliRunner().invoke(app, args)
+
+ assert result.exit_code != 0
+ assert result.exception is None or isinstance(result.exception, SystemExit)
+ assert "Failed to update workflow registry" in result.output
+ dest_dir = project_dir / ".specify" / "workflows" / "align-wf"
+ assert not dest_dir.exists()
+ assert not WorkflowRegistry(project_dir).is_installed("align-wf")
+
+ @pytest.mark.parametrize("mode", ["dev", "local", "from_url"])
+ def test_add_fresh_install_mkstemp_failure_leaves_no_orphan_directory(
+ self, project_dir, monkeypatch, mode
+ ):
+ """_stage_workflow_file() does mkdir(dest_dir) then mkstemp() inside
+ it. For a fresh install (no prior directory), if mkdir succeeds but
+ mkstemp then fails (disk full/EMFILE/quota), the freshly-created
+ empty dest_dir must not be left orphaned -- it must be removed, and
+ the original mkstemp error must still be reported cleanly."""
+ import contextlib
+ from unittest.mock import patch
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ runner = CliRunner()
+
+ def boom(*args, **kwargs):
+ raise OSError("disk full")
+
+ if mode == "from_url":
+ data = self.WORKFLOW_YAML.format(version="1.0.0").encode()
+ args = ["workflow", "add", "align-wf", "--from", "https://example.com/workflow.yml"]
+ url_patch = patch(
+ "specify_cli.authentication.http.open_url",
+ side_effect=lambda url, timeout=None, extra_headers=None, redirect_validator=None: self._FakeResponse(data, url),
+ )
+ else:
+ src = self._write_workflow_dir(project_dir)
+ args = ["workflow", "add", str(src)] + (["--dev"] if mode == "dev" else [])
+ url_patch = contextlib.nullcontext()
+
+ with url_patch, pytest.MonkeyPatch.context() as mp:
+ mp.setattr("tempfile.mkstemp", boom)
+ result = runner.invoke(
+ app, args, input="y\n" if mode == "from_url" else None
+ )
+
+ assert result.exit_code != 0
+ assert result.exception is None or isinstance(result.exception, SystemExit)
+ assert result.output.strip() != ""
+ dest_dir = project_dir / ".specify" / "workflows" / "align-wf"
+ assert not dest_dir.exists(), "fresh-install dest_dir left orphaned after mkstemp failure"
+ assert not WorkflowRegistry(project_dir).is_installed("align-wf")
+
+ def test_add_reinstall_mkstemp_failure_preserves_preexisting_directory(
+ self, project_dir, monkeypatch
+ ):
+ """A pre-existing (reinstall) dest_dir must never be removed by the
+ mkstemp-failure cleanup -- only a directory _stage_workflow_file
+ itself just created."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ runner = CliRunner()
+ src = self._install_dev(runner, app, project_dir)
+ installed_yaml = project_dir / ".specify" / "workflows" / "align-wf" / "workflow.yml"
+ original_bytes = installed_yaml.read_bytes()
+ original_registry_entry = WorkflowRegistry(project_dir).get("align-wf")
+
+ (src / "workflow.yml").write_text(
+ self.WORKFLOW_YAML.format(version="2.0.0"), encoding="utf-8"
+ )
+
+ def boom(*args, **kwargs):
+ raise OSError("disk full")
+
+ with pytest.MonkeyPatch.context() as mp:
+ mp.setattr("tempfile.mkstemp", boom)
+ result = runner.invoke(app, ["workflow", "add", str(src), "--dev"])
+
+ assert result.exit_code != 0
+ assert result.exception is None or isinstance(result.exception, SystemExit)
+ assert result.output.strip() != ""
+ assert installed_yaml.parent.is_dir()
+ assert installed_yaml.read_bytes() == original_bytes
+ assert WorkflowRegistry(project_dir).get("align-wf") == original_registry_entry
+
+ @pytest.mark.skipif(not hasattr(os, "symlink"), reason="symlinks are unavailable")
+ @pytest.mark.parametrize("mode", ["dev", "catalog"])
+ def test_stage_write_rejects_swapped_symlink(
+ self, project_dir, monkeypatch, mode
+ ):
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows import _commands
+ from specify_cli.workflows.catalog import WorkflowCatalog
+
+ monkeypatch.chdir(project_dir)
+ victim = project_dir / "victim.txt"
+ victim.write_text("untouched", encoding="utf-8")
+
+ real_stage = _commands._stage_workflow_file
+
+ def raced_stage(*args, **kwargs):
+ staged = real_stage(*args, **kwargs)
+ staged_path = getattr(staged, "path", staged)
+ staged_path.unlink()
+ staged_path.symlink_to(victim)
+ return staged
+
+ monkeypatch.setattr(_commands, "_stage_workflow_file", raced_stage)
+
+ if mode == "dev":
+ source = self._write_workflow_dir(project_dir)
+ args = ["workflow", "add", str(source), "--dev"]
+ else:
+ monkeypatch.setattr(
+ WorkflowCatalog,
+ "get_workflow_info",
+ lambda self, wid: {
+ "id": wid,
+ "name": "Align Workflow",
+ "version": "1.0.0",
+ "url": "https://example.com/workflow.yml",
+ "_install_allowed": True,
+ "_catalog_name": "test-catalog",
+ },
+ )
+ data = self.WORKFLOW_YAML.format(version="1.0.0").encode()
+ monkeypatch.setattr(
+ "specify_cli.authentication.http.open_url",
+ lambda url, timeout=None, extra_headers=None,
+ redirect_validator=None: self._FakeResponse(data, url),
+ )
+ args = ["workflow", "add", "align-wf"]
+
+ result = CliRunner().invoke(app, args)
+
+ assert result.exit_code != 0
+ assert victim.read_text(encoding="utf-8") == "untouched"
+
+ def test_local_install_writes_the_same_bytes_it_validates(
+ self, project_dir, monkeypatch
+ ):
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows import _commands
+ from specify_cli.workflows.catalog import WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ source = self._write_workflow_dir(project_dir)
+ source_file = source / "workflow.yml"
+ validated_content = source_file.read_text(encoding="utf-8")
+ replacement_content = self.WORKFLOW_YAML.format(version="9.9.9")
+
+ real_stage = _commands._stage_workflow_file
+
+ def replace_source_after_validation(*args, **kwargs):
+ staged = real_stage(*args, **kwargs)
+ source_file.write_text(replacement_content, encoding="utf-8")
+ return staged
+
+ monkeypatch.setattr(
+ _commands,
+ "_stage_workflow_file",
+ replace_source_after_validation,
+ )
+
+ result = CliRunner().invoke(
+ app, ["workflow", "add", str(source), "--dev"]
+ )
+
+ assert result.exit_code == 0, result.output
+ installed_file = (
+ project_dir
+ / ".specify"
+ / "workflows"
+ / "align-wf"
+ / "workflow.yml"
+ )
+ assert installed_file.read_text(encoding="utf-8") == validated_content
+ assert WorkflowRegistry(project_dir).get("align-wf")["version"] == "1.0.0"
+
+ def test_add_fresh_install_staged_discard_cleanup_failure_reports_warning(
+ self, project_dir, monkeypatch
+ ):
+ """A genuine fresh-directory rmdir failure must be reported while
+ the original copy failure remains the primary error."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows import _commands
+ from specify_cli.workflows.catalog import WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ runner = CliRunner()
+ src = self._write_workflow_dir(project_dir)
+
+ def copy_boom(self, data):
+ raise OSError("disk full")
+
+ real_rmdir = Path.rmdir
+
+ def rmdir_boom(path):
+ if path.name == "align-wf":
+ raise OSError("cleanup denied")
+ return real_rmdir(path)
+
+ with pytest.MonkeyPatch.context() as mp:
+ mp.setattr(_commands._StagedWorkflowFile, "write_bytes", copy_boom)
+ mp.setattr(Path, "rmdir", rmdir_boom)
+ result = runner.invoke(app, ["workflow", "add", str(src), "--dev"])
+
+ assert result.exit_code != 0
+ assert result.exception is None or isinstance(result.exception, SystemExit)
+ # Original install error remains present and primary.
+ assert "disk full" in result.output
+ # Cleanup failure is now reported, not silently swallowed.
+ assert "cleanup denied" in result.output
+ assert "Warning" in result.output
+ assert not WorkflowRegistry(project_dir).is_installed("align-wf")
+
+ def test_add_fresh_install_registry_rollback_cleanup_failure_reports_warning(
+ self, project_dir, monkeypatch
+ ):
+ """A fresh-install rollback directory-removal failure must be
+ reported while the registry-update error remains primary."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ runner = CliRunner()
+ src = self._write_workflow_dir(project_dir)
+
+ def save_boom(self):
+ raise OSError("registry disk full")
+
+ real_rmdir = Path.rmdir
+
+ def rmdir_boom(path):
+ if path.name == "align-wf":
+ raise OSError("cleanup denied")
+ return real_rmdir(path)
+
+ with pytest.MonkeyPatch.context() as mp:
+ mp.setattr(WorkflowRegistry, "save", save_boom)
+ mp.setattr(Path, "rmdir", rmdir_boom)
+ result = runner.invoke(app, ["workflow", "add", str(src), "--dev"])
+
+ assert result.exit_code != 0
+ assert result.exception is None or isinstance(result.exception, SystemExit)
+ # Original registry-update error remains present and primary.
+ assert "registry disk full" in result.output
+ # Cleanup failure is now reported, not silently swallowed.
+ assert "cleanup denied" in result.output
+ assert "Warning" in result.output
+
+ def test_add_dev_reinstall_copy_failure_leaves_prior_file_untouched(
+ self, project_dir, monkeypatch
+ ):
+ """A staged descriptor-copy failure cannot touch the prior installed
+ workflow or leave a staging file behind."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows import _commands
+ from specify_cli.workflows.catalog import WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ runner = CliRunner()
+ src = self._install_dev(runner, app, project_dir)
+ installed_yaml = project_dir / ".specify" / "workflows" / "align-wf" / "workflow.yml"
+ original_bytes = installed_yaml.read_bytes()
+ original_registry_entry = WorkflowRegistry(project_dir).get("align-wf")
+
+ # Point --dev at a new version of the same workflow to trigger a
+ # reinstall (overwrite) rather than a fresh install.
+ (src / "workflow.yml").write_text(
+ self.WORKFLOW_YAML.format(version="2.0.0"), encoding="utf-8"
+ )
+
+ def boom(staged, data):
+ # Simulate a truncating partial write followed by an OSError on
+ # the reserved staging inode, mirroring disk exhaustion.
+ os.ftruncate(staged.fd, 0)
+ raise OSError("disk full")
+
+ with pytest.MonkeyPatch.context() as mp:
+ mp.setattr(_commands._StagedWorkflowFile, "write_bytes", boom)
+ result = runner.invoke(app, ["workflow", "add", str(src), "--dev"])
+
+ assert result.exit_code != 0
+ assert result.exception is None or isinstance(result.exception, SystemExit)
+ assert result.output.strip() != ""
+ assert installed_yaml.read_bytes() == original_bytes
+ assert WorkflowRegistry(project_dir).get("align-wf") == original_registry_entry
+ # No orphaned staging file left behind in the workflow directory.
+ leftovers = [p.name for p in installed_yaml.parent.iterdir() if p.name != "workflow.yml"]
+ assert leftovers == []
+
+ def test_add_dev_successful_reinstall_leaves_no_backup_file(
+ self, project_dir, monkeypatch
+ ):
+ """Once registry.add() succeeds, the unique rollback backup must be
+ discarded rather than left as a permanent orphan sibling."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ runner = CliRunner()
+ src = self._install_dev(runner, app, project_dir)
+ workflow_dir = project_dir / ".specify" / "workflows" / "align-wf"
+
+ # Reinstall (overwrite) with a new version -- a successful reinstall,
+ # not a failure path.
+ (src / "workflow.yml").write_text(
+ self.WORKFLOW_YAML.format(version="2.0.0"), encoding="utf-8"
+ )
+ result = runner.invoke(app, ["workflow", "add", str(src), "--dev"])
+
+ assert result.exit_code == 0, result.output
+ registry = WorkflowRegistry(project_dir)
+ assert registry.is_installed("align-wf")
+ assert registry.get("align-wf")["version"] == "2.0.0"
+ assert (workflow_dir / "workflow.yml").read_text(encoding="utf-8") == (
+ self.WORKFLOW_YAML.format(version="2.0.0")
+ )
+ leftovers = [p.name for p in workflow_dir.iterdir() if p.name != "workflow.yml"]
+ assert leftovers == [], f"orphan sibling(s) left behind: {leftovers}"
+
+ def test_add_dev_successful_reinstall_backup_cleanup_failure_still_succeeds(
+ self, project_dir, monkeypatch
+ ):
+ """A failure to clean up the now-unneeded backup file after a
+ successful registry.add() must not turn the already-successful
+ install into a reported failure: it must be a warning (exit 0),
+ consistent with workflow_remove's post-commit cleanup semantics."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ runner = CliRunner()
+ src = self._install_dev(runner, app, project_dir)
+
+ (src / "workflow.yml").write_text(
+ self.WORKFLOW_YAML.format(version="2.0.0"), encoding="utf-8"
+ )
+
+ real_unlink = Path.unlink
+
+ def unlink_boom(self_path, *args, **kwargs):
+ if self_path.name.endswith(".bak"):
+ raise OSError("permission denied")
+ return real_unlink(self_path, *args, **kwargs)
+
+ with pytest.MonkeyPatch.context() as mp:
+ mp.setattr(Path, "unlink", unlink_boom)
+ result = runner.invoke(app, ["workflow", "add", str(src), "--dev"])
+
+ assert result.exit_code == 0, result.output
+ assert "Warning" in result.output
+ assert "permissiondenied" in "".join(result.output.split())
+ registry = WorkflowRegistry(project_dir)
+ assert registry.is_installed("align-wf")
+ assert registry.get("align-wf")["version"] == "2.0.0"
+
+ def test_add_dev_reinstall_restore_failure_reports_warning_and_original_error(
+ self, project_dir, monkeypatch
+ ):
+ """The prior file is now restored via an atomic rename (not a
+ content rewrite) when registry.add() fails on a reinstall. If that
+ restore rename itself also fails (e.g. a transient FS issue), it
+ must not silently claim success or crash with a raw traceback: it
+ must report a clear warning about the restore failure in addition
+ to the original clean registry error."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ runner = CliRunner()
+ src = self._install_dev(runner, app, project_dir)
+
+ (src / "workflow.yml").write_text(
+ self.WORKFLOW_YAML.format(version="2.0.0"), encoding="utf-8"
+ )
+
+ def save_boom(self):
+ raise OSError("disk full")
+
+ real_replace = os.replace
+ calls = {"n": 0}
+
+ def replace_boom(src_path, dst_path):
+ # The commit swap for a reinstall makes exactly two os.replace
+ # calls (backup-aside, then staged-into-dest); let both succeed
+ # and only fail the third call -- the post-registry-failure
+ # restore-back rename.
+ calls["n"] += 1
+ if calls["n"] <= 2:
+ return real_replace(src_path, dst_path)
+ raise OSError("permission denied")
+
+ with pytest.MonkeyPatch.context() as mp:
+ mp.setattr(WorkflowRegistry, "save", save_boom)
+ mp.setattr(os, "replace", replace_boom)
+ result = runner.invoke(app, ["workflow", "add", str(src), "--dev"])
+
+
+ assert result.exit_code != 0
+ assert result.exception is None or isinstance(result.exception, SystemExit)
+ output_compact = "".join(result.output.split())
+ assert "Warning" in result.output
+ assert "diskfull" in output_compact
+ assert "permissiondenied" in output_compact
+
+ def test_add_dev_fresh_install_into_preexisting_empty_dir_cleans_new_file(
+ self, project_dir, monkeypatch
+ ):
+ """When the destination directory already exists but has no
+ workflow.yml (e.g. an empty dir left over from elsewhere), a later
+ registry.add() failure must remove the newly copied file -- the
+ rollback previously did nothing in this case (existed_before=True
+ with no backup bytes), leaving the new file behind -- while leaving
+ the pre-existing directory itself intact."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ runner = CliRunner()
+ src = self._write_workflow_dir(project_dir)
+ dest_dir = project_dir / ".specify" / "workflows" / "align-wf"
+ dest_dir.mkdir(parents=True) # pre-existing, but empty: no workflow.yml
+
+ def boom(self, *args, **kwargs):
+ raise OSError("disk full")
+
+ with pytest.MonkeyPatch.context() as mp:
+ mp.setattr(WorkflowRegistry, "add", boom)
+ result = runner.invoke(app, ["workflow", "add", str(src), "--dev"])
+
+ assert result.exit_code != 0
+ assert result.output.strip() != ""
+ assert dest_dir.is_dir()
+ assert not (dest_dir / "workflow.yml").exists()
+
+ def test_add_catalog_save_failure_leaves_no_orphan_directory(self, project_dir, monkeypatch):
+ """Same guarantee as the local-install paths, but for a fresh catalog
+ install: a registry.add() failure must clean up the freshly-downloaded
+ directory and fail with a clean escaped message."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowCatalog, WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ monkeypatch.setattr(
+ WorkflowCatalog,
+ "get_workflow_info",
+ lambda self, wid: {
+ "id": wid,
+ "name": "Align Workflow",
+ "version": "1.0.0",
+ "url": "https://example.com/workflow.yml",
+ "_install_allowed": True,
+ "_catalog_name": "test-catalog",
+ },
+ )
+ data = self.WORKFLOW_YAML.format(version="1.0.0").encode()
+
+ def boom(self):
+ raise OSError("disk full")
+
+ runner = CliRunner()
+ with pytest.MonkeyPatch.context() as mp:
+ mp.setattr(
+ "specify_cli.authentication.http.open_url",
+ lambda url, timeout=None, extra_headers=None, redirect_validator=None: self._FakeResponse(data, url),
+ )
+ mp.setattr(WorkflowRegistry, "save", boom)
+ result = runner.invoke(app, ["workflow", "add", "align-wf"])
+
+ assert result.exit_code != 0
+ assert result.exception is None or isinstance(result.exception, SystemExit)
+ assert result.output.strip() != ""
+ dest_dir = project_dir / ".specify" / "workflows" / "align-wf"
+ assert not dest_dir.exists()
+ assert not WorkflowRegistry(project_dir).is_installed("align-wf")
+
+ def test_add_catalog_fresh_install_mkstemp_failure_leaves_no_orphan_directory(
+ self, project_dir, monkeypatch
+ ):
+ """Same guarantee as the local-install fresh-install case, but for a
+ fresh catalog install: if _stage_workflow_file's mkdir succeeds but
+ its mkstemp then fails, the freshly-created empty directory must not
+ be left orphaned."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowCatalog, WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ monkeypatch.setattr(
+ WorkflowCatalog,
+ "get_workflow_info",
+ lambda self, wid: {
+ "id": wid,
+ "name": "Align Workflow",
+ "version": "1.0.0",
+ "url": "https://example.com/workflow.yml",
+ "_install_allowed": True,
+ "_catalog_name": "test-catalog",
+ },
+ )
+ data = self.WORKFLOW_YAML.format(version="1.0.0").encode()
+
+ def boom(*args, **kwargs):
+ raise OSError("disk full")
+
+ runner = CliRunner()
+ with pytest.MonkeyPatch.context() as mp:
+ mp.setattr(
+ "specify_cli.authentication.http.open_url",
+ lambda url, timeout=None, extra_headers=None, redirect_validator=None: self._FakeResponse(data, url),
+ )
+ mp.setattr("tempfile.mkstemp", boom)
+ result = runner.invoke(app, ["workflow", "add", "align-wf"])
+
+ assert result.exit_code != 0
+ assert result.exception is None or isinstance(result.exception, SystemExit)
+ assert result.output.strip() != ""
+ dest_dir = project_dir / ".specify" / "workflows" / "align-wf"
+ assert not dest_dir.exists(), "fresh-install dest_dir left orphaned after mkstemp failure"
+ assert not WorkflowRegistry(project_dir).is_installed("align-wf")
+
+ def test_add_catalog_rejects_oversized_content_length(self, project_dir, monkeypatch):
+ """Catalog installs must share the same size cap as --from: a
+ response that declares an oversized Content-Length is rejected
+ before its body is read into memory, and no orphan directory or
+ registry mutation is left behind."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows import _commands as wf_commands
+ from specify_cli.workflows.catalog import WorkflowCatalog, WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ monkeypatch.setattr(wf_commands, "_MAX_WORKFLOW_YAML_BYTES", 100)
+ monkeypatch.setattr(
+ WorkflowCatalog,
+ "get_workflow_info",
+ lambda self, wid: {
+ "id": wid,
+ "name": "Align Workflow",
+ "version": "1.0.0",
+ "url": "https://example.com/workflow.yml",
+ "_install_allowed": True,
+ "_catalog_name": "test-catalog",
+ },
+ )
+ small_body = b"id: align-wf\n" # actual body is small; header lies
+ runner = CliRunner()
+ with pytest.MonkeyPatch.context() as mp:
+ mp.setattr(
+ "specify_cli.authentication.http.open_url",
+ lambda url, timeout=None, extra_headers=None, redirect_validator=None: self._FakeResponse(
+ small_body, url, headers={"Content-Length": "1000"}
+ ),
+ )
+ result = runner.invoke(app, ["workflow", "add", "align-wf"])
+
+ assert result.exit_code != 0
+ assert result.exception is None or isinstance(result.exception, SystemExit)
+ assert "exceedingthe100-byteworkflowsizelimit" in "".join(result.output.split())
+ dest_dir = project_dir / ".specify" / "workflows" / "align-wf"
+ assert not dest_dir.exists()
+ assert not WorkflowRegistry(project_dir).is_installed("align-wf")
+
+ def test_add_catalog_rejects_oversized_streamed_body_without_content_length(
+ self, project_dir, monkeypatch
+ ):
+ """Catalog installs must also cap actual streamed bytes when
+ Content-Length is absent or understated, leaving no orphan
+ directory or registry mutation behind."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows import _commands as wf_commands
+ from specify_cli.workflows.catalog import WorkflowCatalog, WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ monkeypatch.setattr(wf_commands, "_MAX_WORKFLOW_YAML_BYTES", 100)
+ monkeypatch.setattr(
+ WorkflowCatalog,
+ "get_workflow_info",
+ lambda self, wid: {
+ "id": wid,
+ "name": "Align Workflow",
+ "version": "1.0.0",
+ "url": "https://example.com/workflow.yml",
+ "_install_allowed": True,
+ "_catalog_name": "test-catalog",
+ },
+ )
+ oversized_body = b"x" * 500 # no Content-Length header at all
+ runner = CliRunner()
+ with pytest.MonkeyPatch.context() as mp:
+ mp.setattr(
+ "specify_cli.authentication.http.open_url",
+ lambda url, timeout=None, extra_headers=None, redirect_validator=None: self._FakeResponse(
+ oversized_body, url
+ ),
+ )
+ result = runner.invoke(app, ["workflow", "add", "align-wf"])
+
+ assert result.exit_code != 0
+ assert result.exception is None or isinstance(result.exception, SystemExit)
+ assert "exceedsthe100-byteworkflowsizelimit" in "".join(result.output.split())
+ dest_dir = project_dir / ".specify" / "workflows" / "align-wf"
+ assert not dest_dir.exists()
+ assert not WorkflowRegistry(project_dir).is_installed("align-wf")
+
+ def test_add_catalog_reinstall_save_failure_restores_prior_file(self, project_dir, monkeypatch):
+ """Re-adding an already-installed catalog workflow downloads the new
+ version over the existing install directory. If registry.add() then
+ fails to save, the prior working workflow.yml must be restored
+ byte-for-byte (not left overwritten with the new download, and not
+ deleted like a fresh install) and the registry must remain valid and
+ still point at the original version -- the update path's caller has
+ an outer backup/restore for this, but plain `workflow add` does not,
+ so _install_workflow_from_catalog must handle it itself."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowCatalog, WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ monkeypatch.setattr(
+ WorkflowCatalog,
+ "get_workflow_info",
+ lambda self, wid: {
+ "id": wid,
+ "name": "Align Workflow",
+ "version": "1.0.0",
+ "url": "https://example.com/workflow.yml",
+ "_install_allowed": True,
+ "_catalog_name": "test-catalog",
+ },
+ )
+ source_data = self.WORKFLOW_YAML.format(version="1.0.0").encode()
+ runner = CliRunner()
+ with pytest.MonkeyPatch.context() as mp:
+ mp.setattr(
+ "specify_cli.authentication.http.open_url",
+ lambda url, timeout=None, extra_headers=None, redirect_validator=None: self._FakeResponse(
+ source_data, url
+ ),
+ )
+ result = runner.invoke(app, ["workflow", "add", "align-wf"])
+ assert result.exit_code == 0, result.output
+
+ dest_file = project_dir / ".specify" / "workflows" / "align-wf" / "workflow.yml"
+ original_data = dest_file.read_bytes()
+
+ new_data = self.WORKFLOW_YAML.format(version="2.0.0").encode()
+
+ def boom(self):
+ raise OSError("disk full")
+
+ with pytest.MonkeyPatch.context() as mp:
+ mp.setattr(
+ "specify_cli.authentication.http.open_url",
+ lambda url, timeout=None, extra_headers=None, redirect_validator=None: self._FakeResponse(
+ new_data, url
+ ),
+ )
+ mp.setattr(WorkflowRegistry, "save", boom)
+ result = runner.invoke(app, ["workflow", "add", "align-wf"])
+
+ assert result.exit_code != 0
+ assert result.exception is None or isinstance(result.exception, SystemExit)
+ assert result.output.strip() != ""
+ # The prior working install must survive untouched, byte-for-byte.
+ assert dest_file.read_bytes() == original_data
+ registry = WorkflowRegistry(project_dir)
+ assert registry.is_installed("align-wf")
+ assert registry.get("align-wf")["version"] == "1.0.0"
+
+ def test_add_catalog_successful_reinstall_leaves_no_backup_file(
+ self, project_dir, monkeypatch
+ ):
+ """Same orphan-backup gap as the local-install path: a successful
+ catalog reinstall must not leave its unique backup behind once
+ registry.add() durably succeeds."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowCatalog, WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ monkeypatch.setattr(
+ WorkflowCatalog,
+ "get_workflow_info",
+ lambda self, wid: {
+ "id": wid,
+ "name": "Align Workflow",
+ "version": "1.0.0",
+ "url": "https://example.com/workflow.yml",
+ "_install_allowed": True,
+ "_catalog_name": "test-catalog",
+ },
+ )
+ original_data = self.WORKFLOW_YAML.format(version="1.0.0").encode()
+ runner = CliRunner()
+ with pytest.MonkeyPatch.context() as mp:
+ mp.setattr(
+ "specify_cli.authentication.http.open_url",
+ lambda url, timeout=None, extra_headers=None, redirect_validator=None: self._FakeResponse(
+ original_data, url
+ ),
+ )
+ result = runner.invoke(app, ["workflow", "add", "align-wf"])
+ assert result.exit_code == 0, result.output
+
+ new_data = self.WORKFLOW_YAML.format(version="2.0.0").encode()
+ with pytest.MonkeyPatch.context() as mp:
+ mp.setattr(
+ "specify_cli.authentication.http.open_url",
+ lambda url, timeout=None, extra_headers=None, redirect_validator=None: self._FakeResponse(
+ new_data, url
+ ),
+ )
+ result = runner.invoke(app, ["workflow", "add", "align-wf"])
+
+ assert result.exit_code == 0, result.output
+ workflow_dir = project_dir / ".specify" / "workflows" / "align-wf"
+ registry = WorkflowRegistry(project_dir)
+ assert registry.is_installed("align-wf")
+ assert registry.get("align-wf")["version"] == "2.0.0"
+ assert (workflow_dir / "workflow.yml").read_bytes() == new_data
+ leftovers = [p.name for p in workflow_dir.iterdir() if p.name != "workflow.yml"]
+ assert leftovers == [], f"orphan sibling(s) left behind: {leftovers}"
+
+ @pytest.mark.skipif(os.name == "nt", reason="POSIX permission bits")
+ def test_add_catalog_fresh_install_uses_project_file_mode(
+ self, project_dir, monkeypatch
+ ):
+ import stat
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowCatalog
+
+ monkeypatch.chdir(project_dir)
+ monkeypatch.setattr(
+ WorkflowCatalog,
+ "get_workflow_info",
+ lambda self, wid: {
+ "id": wid,
+ "name": "Align Workflow",
+ "version": "1.0.0",
+ "url": "https://example.com/workflow.yml",
+ "_install_allowed": True,
+ "_catalog_name": "test-catalog",
+ },
+ )
+ data = self.WORKFLOW_YAML.format(version="1.0.0").encode()
+
+ previous_umask = os.umask(0o022)
+ try:
+ with pytest.MonkeyPatch.context() as mp:
+ mp.setattr(
+ "specify_cli.authentication.http.open_url",
+ lambda url, timeout=None, extra_headers=None,
+ redirect_validator=None: self._FakeResponse(data, url),
+ )
+ result = CliRunner().invoke(
+ app, ["workflow", "add", "align-wf"]
+ )
+ finally:
+ os.umask(previous_umask)
+
+ assert result.exit_code == 0, result.output
+ workflow_file = (
+ project_dir
+ / ".specify"
+ / "workflows"
+ / "align-wf"
+ / "workflow.yml"
+ )
+ assert stat.S_IMODE(workflow_file.stat().st_mode) == 0o644
+
+ def test_concurrent_catalog_reinstalls_keep_file_and_registry_aligned(
+ self, project_dir, monkeypatch
+ ):
+ import threading
+ from specify_cli.workflows import _commands
+ from specify_cli.workflows.catalog import WorkflowCatalog, WorkflowRegistry
+ from specify_cli.workflows.engine import WorkflowDefinition
+
+ workflows_dir = project_dir / ".specify" / "workflows"
+ workflow_file = workflows_dir / "align-wf" / "workflow.yml"
+ workflow_file.parent.mkdir(parents=True)
+ workflow_file.write_text(
+ self.WORKFLOW_YAML.format(version="1.0.0"), encoding="utf-8"
+ )
+ WorkflowRegistry(project_dir).add(
+ "align-wf",
+ {
+ "name": "Align Workflow",
+ "version": "1.0.0",
+ "source": "catalog",
+ },
+ )
+
+ versions = {"install-a": "2.0.0", "install-b": "3.0.0"}
+ monkeypatch.setattr(
+ WorkflowCatalog,
+ "get_workflow_info",
+ lambda self, wid: {
+ "id": wid,
+ "name": "Align Workflow",
+ "version": versions[threading.current_thread().name],
+ "url": (
+ "https://example.com/"
+ f"{versions[threading.current_thread().name]}.yml"
+ ),
+ "_install_allowed": True,
+ "_catalog_name": "test-catalog",
+ },
+ )
+ monkeypatch.setattr(
+ "specify_cli.authentication.http.open_url",
+ lambda url, timeout=None, extra_headers=None,
+ redirect_validator=None: self._FakeResponse(
+ self.WORKFLOW_YAML.format(
+ version=url.rsplit("/", 1)[-1].removesuffix(".yml")
+ ).encode(),
+ url,
+ ),
+ )
+
+ a_committed = threading.Event()
+ b_committed = threading.Event()
+ a_saving = threading.Event()
+ b_saved = threading.Event()
+ real_commit = _commands._commit_workflow_file
+ real_save = WorkflowRegistry.save
+
+ def coordinated_commit(*args, **kwargs):
+ backup = real_commit(*args, **kwargs)
+ if threading.current_thread().name == "install-a":
+ a_committed.set()
+ b_committed.wait(0.5)
+ else:
+ b_committed.set()
+ return backup
+
+ def coordinated_save(registry):
+ if threading.current_thread().name == "install-a":
+ a_saving.set()
+ b_saved.wait(0.5)
+ return real_save(registry)
+ assert a_saving.wait(2)
+ real_save(registry)
+ b_saved.set()
+
+ monkeypatch.setattr(
+ _commands, "_commit_workflow_file", coordinated_commit
+ )
+ monkeypatch.setattr(WorkflowRegistry, "save", coordinated_save)
+
+ errors = []
+
+ def install():
+ try:
+ _commands._install_workflow_from_catalog(
+ project_dir,
+ workflows_dir,
+ "align-wf",
+ )
+ except BaseException as exc:
+ errors.append(exc)
+
+ first = threading.Thread(target=install, name="install-a")
+ second = threading.Thread(target=install, name="install-b")
+ first.start()
+ assert a_committed.wait(2)
+ second.start()
+ first.join(5)
+ second.join(5)
+
+ assert not first.is_alive()
+ assert not second.is_alive()
+ assert errors == []
+ file_version = WorkflowDefinition.from_yaml(workflow_file).version
+ registry_version = WorkflowRegistry(project_dir).get("align-wf")[
+ "version"
+ ]
+ assert file_version == registry_version
+
+ def test_precommit_discard_preserves_concurrent_install(self, project_dir):
+ from specify_cli.workflows import _commands
+
+ workflow_dir = (
+ project_dir / ".specify" / "workflows" / "concurrent-wf"
+ )
+ workflow_dir.mkdir(parents=True)
+ staged_file = workflow_dir / ".workflow.yml.staged.tmp"
+ staged_file.write_text("staged", encoding="utf-8")
+ committed_file = workflow_dir / "workflow.yml"
+ committed_file.write_text("committed", encoding="utf-8")
+
+ _commands._discard_staged_workflow_file(
+ staged_file, workflow_dir, existed_before=False
+ )
+
+ assert committed_file.read_text(encoding="utf-8") == "committed"
+ assert not staged_file.exists()
+
+ def test_fresh_install_rollback_preserves_concurrent_staged_file(
+ self, project_dir
+ ):
+ """A second installer stages before taking the transaction lock, so
+ the first installer's rollback must not recursively remove siblings."""
+ from specify_cli.workflows import _commands
+
+ workflow_dir = (
+ project_dir / ".specify" / "workflows" / "concurrent-wf"
+ )
+ workflow_dir.mkdir(parents=True)
+ committed_file = workflow_dir / "workflow.yml"
+ committed_file.write_text("failed install", encoding="utf-8")
+ concurrent_stage = workflow_dir / ".workflow.yml.concurrent.tmp"
+ concurrent_stage.write_text("next install", encoding="utf-8")
+
+ _commands._rollback_committed_workflow_file(
+ committed_file,
+ workflow_dir,
+ existed_before=False,
+ backup_file=None,
+ )
+
+ assert not committed_file.exists()
+ assert concurrent_stage.read_text(encoding="utf-8") == "next install"
+
+ def test_add_dev_registry_reopen_exit_discards_staged_file(
+ self, project_dir, monkeypatch
+ ):
+ import typer
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows import _commands
+
+ monkeypatch.chdir(project_dir)
+ source_dir = self._write_workflow_dir(project_dir)
+ real_open_registry = _commands._open_workflow_registry
+ calls = 0
+
+ def fail_transaction_reopen(root):
+ nonlocal calls
+ calls += 1
+ if calls == 2:
+ raise typer.Exit(1)
+ return real_open_registry(root)
+
+ monkeypatch.setattr(
+ _commands, "_open_workflow_registry", fail_transaction_reopen
+ )
+ result = CliRunner().invoke(
+ app, ["workflow", "add", str(source_dir), "--dev"]
+ )
+
+ assert result.exit_code != 0
+ assert not (
+ project_dir / ".specify" / "workflows" / "align-wf"
+ ).exists()
+
+ def test_add_catalog_registry_reopen_exit_discards_staged_file(
+ self, project_dir, monkeypatch
+ ):
+ import typer
+ from specify_cli.workflows import _commands
+ from specify_cli.workflows.catalog import WorkflowCatalog
+
+ workflows_dir = project_dir / ".specify" / "workflows"
+ monkeypatch.setattr(
+ WorkflowCatalog,
+ "get_workflow_info",
+ lambda self, wid: {
+ "id": wid,
+ "name": "Align Workflow",
+ "version": "1.0.0",
+ "url": "https://example.com/workflow.yml",
+ "_install_allowed": True,
+ "_catalog_name": "test-catalog",
+ },
+ )
+ data = self.WORKFLOW_YAML.format(version="1.0.0").encode()
+ monkeypatch.setattr(
+ "specify_cli.authentication.http.open_url",
+ lambda url, timeout=None, extra_headers=None,
+ redirect_validator=None: self._FakeResponse(data, url),
+ )
+ monkeypatch.setattr(
+ _commands,
+ "_open_workflow_registry",
+ lambda _root: (_ for _ in ()).throw(typer.Exit(1)),
+ )
+
+ with pytest.raises(typer.Exit):
+ _commands._install_workflow_from_catalog(
+ project_dir,
+ workflows_dir,
+ "align-wf",
+ )
+
+ assert not (workflows_dir / "align-wf").exists()
+
+ def test_remove_serializes_with_concurrent_catalog_install(
+ self, project_dir, monkeypatch
+ ):
+ import threading
+ from specify_cli.workflows import _commands
+ from specify_cli.workflows.catalog import WorkflowCatalog, WorkflowRegistry
+ from specify_cli.workflows.engine import WorkflowDefinition
+
+ workflows_dir = project_dir / ".specify" / "workflows"
+ workflow_file = workflows_dir / "align-wf" / "workflow.yml"
+ workflow_file.parent.mkdir(parents=True)
+ workflow_file.write_text(
+ self.WORKFLOW_YAML.format(version="1.0.0"), encoding="utf-8"
+ )
+ WorkflowRegistry(project_dir).add(
+ "align-wf",
+ {
+ "name": "Align Workflow",
+ "version": "1.0.0",
+ "source": "catalog",
+ },
+ )
+ monkeypatch.setattr(
+ _commands, "_require_specify_project", lambda: project_dir
+ )
+ monkeypatch.setattr(
+ WorkflowCatalog,
+ "get_workflow_info",
+ lambda self, wid: {
+ "id": wid,
+ "name": "Align Workflow",
+ "version": "2.0.0",
+ "url": "https://example.com/workflow.yml",
+ "_install_allowed": True,
+ "_catalog_name": "test-catalog",
+ },
+ )
+ new_data = self.WORKFLOW_YAML.format(version="2.0.0").encode()
+ monkeypatch.setattr(
+ "specify_cli.authentication.http.open_url",
+ lambda url, timeout=None, extra_headers=None,
+ redirect_validator=None: self._FakeResponse(new_data, url),
+ )
+
+ removal_ready = threading.Event()
+ install_done = threading.Event()
+ real_remove = WorkflowRegistry.remove
+
+ def coordinated_remove(registry, workflow_id):
+ if threading.current_thread().name == "remove":
+ removal_ready.set()
+ install_done.wait(0.5)
+ return real_remove(registry, workflow_id)
+
+ monkeypatch.setattr(WorkflowRegistry, "remove", coordinated_remove)
+ errors = []
+
+ def remove():
+ try:
+ _commands.workflow_remove("align-wf")
+ except BaseException as exc:
+ errors.append(exc)
+
+ def install():
+ try:
+ _commands._install_workflow_from_catalog(
+ project_dir,
+ workflows_dir,
+ "align-wf",
+ )
+ except BaseException as exc:
+ errors.append(exc)
+ finally:
+ install_done.set()
+
+ remove_thread = threading.Thread(target=remove, name="remove")
+ install_thread = threading.Thread(target=install, name="install")
+ remove_thread.start()
+ assert removal_ready.wait(2)
+ install_thread.start()
+ remove_thread.join(5)
+ install_thread.join(5)
+
+ assert not remove_thread.is_alive()
+ assert not install_thread.is_alive()
+ assert errors == []
+ assert WorkflowDefinition.from_yaml(workflow_file).version == "2.0.0"
+ metadata = WorkflowRegistry(project_dir).get("align-wf")
+ assert metadata["version"] == "2.0.0"
+
+ @pytest.mark.parametrize(
+ ("command_name", "initial_enabled", "expected_enabled"),
+ [
+ ("enable", False, True),
+ ("disable", True, False),
+ ],
+ )
+ def test_toggle_serializes_with_concurrent_catalog_update(
+ self,
+ project_dir,
+ monkeypatch,
+ command_name,
+ initial_enabled,
+ expected_enabled,
+ ):
+ import threading
+ from specify_cli.workflows import _commands
+ from specify_cli.workflows.catalog import WorkflowCatalog, WorkflowRegistry
+ from specify_cli.workflows.engine import WorkflowDefinition
+
+ workflows_dir = project_dir / ".specify" / "workflows"
+ workflow_file = workflows_dir / "align-wf" / "workflow.yml"
+ workflow_file.parent.mkdir(parents=True)
+ workflow_file.write_text(
+ self.WORKFLOW_YAML.format(version="1.0.0"), encoding="utf-8"
+ )
+ WorkflowRegistry(project_dir).add(
+ "align-wf",
+ {
+ "name": "Align Workflow",
+ "version": "1.0.0",
+ "source": "catalog",
+ "enabled": initial_enabled,
+ },
+ )
+ monkeypatch.setattr(
+ _commands, "_require_specify_project", lambda: project_dir
+ )
+ monkeypatch.setattr(
+ WorkflowCatalog,
+ "get_workflow_info",
+ lambda self, wid: {
+ "id": wid,
+ "name": "Align Workflow",
+ "version": "2.0.0",
+ "url": "https://example.com/workflow.yml",
+ "_install_allowed": True,
+ "_catalog_name": "test-catalog",
+ },
+ )
+ new_data = self.WORKFLOW_YAML.format(version="2.0.0").encode()
+ monkeypatch.setattr(
+ "specify_cli.authentication.http.open_url",
+ lambda url, timeout=None, extra_headers=None,
+ redirect_validator=None: self._FakeResponse(new_data, url),
+ )
+
+ toggle_ready = threading.Event()
+ update_done = threading.Event()
+ real_add = WorkflowRegistry.add
+
+ def coordinated_add(registry, workflow_id, metadata):
+ if threading.current_thread().name == "toggle":
+ toggle_ready.set()
+ update_done.wait(0.5)
+ return real_add(registry, workflow_id, metadata)
+
+ monkeypatch.setattr(WorkflowRegistry, "add", coordinated_add)
+ errors = []
+
+ def toggle():
+ try:
+ getattr(_commands, f"workflow_{command_name}")("align-wf")
+ except BaseException as exc:
+ errors.append(exc)
+
+ def update():
+ try:
+ _commands._install_workflow_from_catalog(
+ project_dir,
+ workflows_dir,
+ "align-wf",
+ )
+ except BaseException as exc:
+ errors.append(exc)
+ finally:
+ update_done.set()
+
+ toggle_thread = threading.Thread(target=toggle, name="toggle")
+ update_thread = threading.Thread(target=update, name="update")
+ toggle_thread.start()
+ assert toggle_ready.wait(2)
+ update_thread.start()
+ toggle_thread.join(5)
+ update_thread.join(5)
+
+ assert not toggle_thread.is_alive()
+ assert not update_thread.is_alive()
+ assert errors == []
+ assert WorkflowDefinition.from_yaml(workflow_file).version == "2.0.0"
+ metadata = WorkflowRegistry(project_dir).get("align-wf")
+ assert metadata["version"] == "2.0.0"
+ assert metadata.get("enabled", True) is expected_enabled
+
+ def test_add_catalog_reinstall_restore_failure_reports_warning_and_original_error(
+ self, project_dir, monkeypatch
+ ):
+ """Same restore-rename boundary as the local-install path: the
+ prior file is restored via an atomic rename (not a content rewrite)
+ when registry.add() fails on a reinstall. If that restore rename
+ itself also fails, it must report a clear warning in addition to
+ the original clean registry error, never crash or silently claim
+ success."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowCatalog, WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ monkeypatch.setattr(
+ WorkflowCatalog,
+ "get_workflow_info",
+ lambda self, wid: {
+ "id": wid,
+ "name": "Align Workflow",
+ "version": "1.0.0",
+ "url": "https://example.com/workflow.yml",
+ "_install_allowed": True,
+ "_catalog_name": "test-catalog",
+ },
+ )
+ original_data = self.WORKFLOW_YAML.format(version="1.0.0").encode()
+ runner = CliRunner()
+ with pytest.MonkeyPatch.context() as mp:
+ mp.setattr(
+ "specify_cli.authentication.http.open_url",
+ lambda url, timeout=None, extra_headers=None, redirect_validator=None: self._FakeResponse(
+ original_data, url
+ ),
+ )
+ result = runner.invoke(app, ["workflow", "add", "align-wf"])
+ assert result.exit_code == 0, result.output
+
+ new_data = self.WORKFLOW_YAML.format(version="2.0.0").encode()
+
+ def save_boom(self):
+ raise OSError("disk full")
+
+ real_replace = os.replace
+ calls = {"n": 0}
+
+ def replace_boom(src_path, dst_path):
+ # The commit swap for a reinstall makes exactly two os.replace
+ # calls (backup-aside, then staged-into-dest); let both succeed
+ # and only fail the third call -- the post-registry-failure
+ # restore-back rename.
+ calls["n"] += 1
+ if calls["n"] <= 2:
+ return real_replace(src_path, dst_path)
+ raise OSError("permission denied")
+
+ with pytest.MonkeyPatch.context() as mp:
+ mp.setattr(
+ "specify_cli.authentication.http.open_url",
+ lambda url, timeout=None, extra_headers=None, redirect_validator=None: self._FakeResponse(
+ new_data, url
+ ),
+ )
+ mp.setattr(WorkflowRegistry, "save", save_boom)
+ mp.setattr(os, "replace", replace_boom)
+ result = runner.invoke(app, ["workflow", "add", "align-wf"])
+
+ assert result.exit_code != 0
+ assert result.exception is None or isinstance(result.exception, SystemExit)
+ output_compact = "".join(result.output.split())
+ assert "Warning" in result.output
+ assert "diskfull" in output_compact
+ assert "permissiondenied" in output_compact
+
+ def test_add_catalog_fresh_install_into_preexisting_empty_dir_cleans_new_file(
+ self, project_dir, monkeypatch
+ ):
+ """Same rollback orphan gap as the local-install path, but for a
+ fresh catalog install: a pre-existing empty destination directory
+ (no workflow.yml) sets existed_before=True with no backup bytes, so
+ the rollback previously did nothing on a later failure -- leaving
+ the freshly downloaded workflow.yml behind. It must be removed,
+ leaving the pre-existing directory itself intact."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowCatalog, WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ monkeypatch.setattr(
+ WorkflowCatalog,
+ "get_workflow_info",
+ lambda self, wid: {
+ "id": wid,
+ "name": "Align Workflow",
+ "version": "1.0.0",
+ "url": "https://example.com/workflow.yml",
+ "_install_allowed": True,
+ "_catalog_name": "test-catalog",
+ },
+ )
+ dest_dir = project_dir / ".specify" / "workflows" / "align-wf"
+ dest_dir.mkdir(parents=True) # pre-existing, but empty: no workflow.yml
+ data = self.WORKFLOW_YAML.format(version="1.0.0").encode()
+
+ def boom(self):
+ raise OSError("disk full")
+
+ runner = CliRunner()
+ with pytest.MonkeyPatch.context() as mp:
+ mp.setattr(
+ "specify_cli.authentication.http.open_url",
+ lambda url, timeout=None, extra_headers=None, redirect_validator=None: self._FakeResponse(data, url),
+ )
+ mp.setattr(WorkflowRegistry, "save", boom)
+ result = runner.invoke(app, ["workflow", "add", "align-wf"])
+
+ assert result.exit_code != 0
+ assert result.output.strip() != ""
+ assert dest_dir.is_dir()
+ assert not (dest_dir / "workflow.yml").exists()
+
+ @pytest.mark.parametrize(
+ "mode", ["redirect_rejected", "download_exception", "invalid_yaml", "id_mismatch"]
+ )
+ def test_add_catalog_reinstall_early_failure_restores_prior_file(
+ self, project_dir, monkeypatch, mode
+ ):
+ """Every _install_workflow_from_catalog failure branch that runs after
+ the mkdir/download step -- not just the registry.add() OSError case
+ -- must route through the same existed-before/backup-aware cleanup:
+ on a reinstall, a redirect rejection, a download exception, invalid
+ YAML, or a workflow-id mismatch must restore the prior working
+ workflow.yml rather than deleting the whole directory. One shared
+ root cause (the cleanup helper), so parametrized over trigger point."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowCatalog, WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ monkeypatch.setattr(
+ WorkflowCatalog,
+ "get_workflow_info",
+ lambda self, wid: {
+ "id": wid,
+ "name": "Align Workflow",
+ "version": "1.0.0",
+ "url": "https://example.com/workflow.yml",
+ "_install_allowed": True,
+ "_catalog_name": "test-catalog",
+ },
+ )
+ source_data = self.WORKFLOW_YAML.format(version="1.0.0").encode()
+ runner = CliRunner()
+ with pytest.MonkeyPatch.context() as mp:
+ mp.setattr(
+ "specify_cli.authentication.http.open_url",
+ lambda url, timeout=None, extra_headers=None, redirect_validator=None: self._FakeResponse(
+ source_data, url
+ ),
+ )
+ result = runner.invoke(app, ["workflow", "add", "align-wf"])
+ assert result.exit_code == 0, result.output
+
+ dest_file = project_dir / ".specify" / "workflows" / "align-wf" / "workflow.yml"
+ original_data = dest_file.read_bytes()
+
+ if mode == "redirect_rejected":
+ def fake_open_url(url, timeout=None, extra_headers=None, redirect_validator=None):
+ return self._FakeResponse(b"irrelevant", "http://evil.example.com/workflow.yml")
+ elif mode == "download_exception":
+ def fake_open_url(url, timeout=None, extra_headers=None, redirect_validator=None):
+ raise OSError("network down")
+ elif mode == "invalid_yaml":
+ def fake_open_url(url, timeout=None, extra_headers=None, redirect_validator=None):
+ return self._FakeResponse(b": : not valid yaml: [", url)
+ else: # id_mismatch
+ mismatched_yaml = self.WORKFLOW_YAML.format(version="2.0.0").replace(
+ 'id: "align-wf"', 'id: "different-workflow"'
+ )
+
+ def fake_open_url(url, timeout=None, extra_headers=None, redirect_validator=None):
+ return self._FakeResponse(mismatched_yaml.encode(), url)
+
+ with pytest.MonkeyPatch.context() as mp:
+ mp.setattr("specify_cli.authentication.http.open_url", fake_open_url)
+ result = runner.invoke(app, ["workflow", "add", "align-wf"])
+
+ assert result.exit_code != 0
+ assert result.exception is None or isinstance(result.exception, SystemExit)
+ assert result.output.strip() != ""
+ assert dest_file.read_bytes() == original_data
+ registry = WorkflowRegistry(project_dir)
+ assert registry.is_installed("align-wf")
+ assert registry.get("align-wf")["version"] == "1.0.0"
+
+ def test_download_redirect_validator_rejects_http_before_follow(self):
+ import urllib.error
+
+ from specify_cli.workflows._commands import _reject_insecure_download_redirect
+
+ with pytest.raises(urllib.error.URLError):
+ _reject_insecure_download_redirect(
+ "https://example.com/wf.yml", "http://evil.example.com/wf.yml"
+ )
+ with pytest.raises(urllib.error.URLError):
+ _reject_insecure_download_redirect(
+ "https://example.com/wf.yml", "http://localhost:8000/wf.yml"
+ )
+ # Allowed: HTTPS anywhere, or loopback HTTP that stays on loopback HTTP.
+ _reject_insecure_download_redirect(
+ "https://example.com/wf.yml", "https://cdn.example.com/wf.yml"
+ )
+ _reject_insecure_download_redirect(
+ "http://localhost:7000/wf.yml", "http://localhost:8000/wf.yml"
+ )
+ _reject_insecure_download_redirect(
+ "http://127.0.0.1/source.yml", "http://127.0.0.1/wf.yml"
+ )
+
+ def test_add_from_url_passes_redirect_validator(self, project_dir, monkeypatch):
+ from unittest.mock import patch
+
+ from typer.testing import CliRunner
+ from specify_cli import app
+
+ monkeypatch.chdir(project_dir)
+ data = self.WORKFLOW_YAML.format(version="1.0.0").encode()
+ seen: dict[str, object] = {}
+
+ def fake_open(url, timeout=None, extra_headers=None, redirect_validator=None):
+ seen["validator"] = redirect_validator
+ return self._FakeResponse(data, url)
+
+ runner = CliRunner()
+ with patch("specify_cli.authentication.http.open_url", side_effect=fake_open):
+ result = runner.invoke(
+ app,
+ ["workflow", "add", "align-wf", "--from", "https://example.com/workflow.yml"],
+ input="y\n",
+ )
+ assert result.exit_code == 0, result.output
+ from specify_cli.workflows._commands import _reject_insecure_download_redirect
+
+ assert seen["validator"] is _reject_insecure_download_redirect
+
+ @pytest.mark.skipif(sys.platform == "win32", reason="chmod mode bits not reliable on Windows")
+ def test_registry_save_failure_preserves_file_on_disk(self, project_dir, monkeypatch):
+ """A failed dump must not truncate the persisted registry, and must
+ not alter its on-disk mode either -- the chmod-to-match-existing-mode
+ step operates on the temp file, never the target, so a failed save
+ (which never reaches os.replace) cannot touch the original's mode."""
+ from specify_cli.workflows.catalog import WorkflowRegistry
+
+ registry = WorkflowRegistry(project_dir)
+ registry.add("align-wf", {"version": "1.0.0", "source": "catalog"})
+ registry.registry_path.chmod(0o644)
+
+ import specify_cli.workflows.catalog as catalog_mod
+
+ def boom(*args, **kwargs):
+ raise OSError("disk full")
+
+ monkeypatch.setattr(catalog_mod.json, "dump", boom)
+ with pytest.raises(OSError):
+ registry.add("align-wf", {"version": "2.0.0", "source": "catalog"})
+ monkeypatch.undo()
+
+ fresh = WorkflowRegistry(project_dir)
+ assert fresh.get("align-wf")["version"] == "1.0.0"
+ assert stat.S_IMODE(registry.registry_path.stat().st_mode) == 0o644
+ assert not list(registry.workflows_dir.glob("*.tmp"))
+
+ def test_update_mixed_targets_does_not_claim_all_up_to_date(self, project_dir, monkeypatch):
+ """Skipped targets must not be presented as verified up to date."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowCatalog, WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ runner = CliRunner()
+ self._install_dev(runner, app, project_dir) # local source β†’ skipped
+ WorkflowRegistry(project_dir).add("catalog-wf", {
+ "name": "Catalog Workflow",
+ "version": "1.0.0",
+ "description": "",
+ "source": "catalog",
+ "url": "https://example.com/workflow.yml",
+ })
+ monkeypatch.setattr(
+ WorkflowCatalog,
+ "get_workflow_info",
+ lambda self, wid: {
+ "id": wid,
+ "version": "1.0.0",
+ "url": "https://example.com/workflow.yml",
+ "_install_allowed": True,
+ },
+ )
+ result = runner.invoke(app, ["workflow", "update"])
+ assert result.exit_code == 0, result.output
+ assert "All workflows are up to date!" not in result.output
+ assert "All checked workflows are up to date" in result.output
+ assert "skipped" in result.output
+
+ def test_run_refuses_falsy_non_bool_enabled(self, project_dir, monkeypatch):
+ """A falsy non-bool "enabled" (0) shows as disabled in list β€” run must agree."""
+ import json as json_mod
+
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ runner = CliRunner()
+ self._install_dev(runner, app, project_dir)
+
+ registry = WorkflowRegistry(project_dir)
+ registry.data["workflows"]["align-wf"]["enabled"] = 0
+ registry.registry_path.write_text(json_mod.dumps(registry.data), encoding="utf-8")
+
+ result = runner.invoke(app, ["workflow", "run", "align-wf"])
+ assert result.exit_code != 0
+ assert "disabled" in result.output
+
+ def test_update_installs_newer_catalog_version(self, project_dir, monkeypatch):
+ from unittest.mock import patch
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowCatalog, WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ registry = WorkflowRegistry(project_dir)
+ registry.add("align-wf", {
+ "name": "Align Workflow",
+ "version": "1.0.0",
+ "description": "CLI alignment test workflow",
+ "source": "catalog",
+ "catalog_name": "test-catalog",
+ "url": "https://example.com/workflow.yml",
+ })
+ wf_dir = project_dir / ".specify" / "workflows" / "align-wf"
+ wf_dir.mkdir(parents=True)
+ (wf_dir / "workflow.yml").write_text(
+ self.WORKFLOW_YAML.format(version="1.0.0"), encoding="utf-8"
+ )
+
+ monkeypatch.setattr(
+ WorkflowCatalog,
+ "get_workflow_info",
+ lambda self, wid: {
+ "id": wid,
+ "name": "Align Workflow",
+ "version": "2.0.0",
+ "url": "https://example.com/workflow.yml",
+ "_install_allowed": True,
+ "_catalog_name": "test-catalog",
+ },
+ )
+ data = self.WORKFLOW_YAML.format(version="2.0.0").encode()
+ runner = CliRunner()
+ with patch(
+ "specify_cli.authentication.http.open_url",
+ side_effect=lambda url, timeout=None, extra_headers=None, redirect_validator=None: self._FakeResponse(data, url),
+ ):
+ result = runner.invoke(app, ["workflow", "update"], input="y\n")
+ assert result.exit_code == 0, result.output
+ assert "1.0.0" in result.output and "2.0.0" in result.output
+ meta = WorkflowRegistry(project_dir).get("align-wf")
+ assert meta["version"] == "2.0.0"
+ assert "2.0.0" in (wf_dir / "workflow.yml").read_text(encoding="utf-8")
+
+ def test_update_downloaded_invalid_yaml_escapes_rich_markup(self, project_dir, monkeypatch):
+ """A malformed downloaded workflow can quote the offending line verbatim; escape it before printing."""
+ from unittest.mock import patch
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowCatalog, WorkflowRegistry
+ from specify_cli.workflows.engine import WorkflowDefinition
+
+ monkeypatch.chdir(project_dir)
+ registry = WorkflowRegistry(project_dir)
+ registry.add("align-wf", {
+ "name": "Align Workflow",
+ "version": "1.0.0",
+ "description": "CLI alignment test workflow",
+ "source": "catalog",
+ "catalog_name": "test-catalog",
+ "url": "https://example.com/workflow.yml",
+ })
+ wf_dir = project_dir / ".specify" / "workflows" / "align-wf"
+ wf_dir.mkdir(parents=True)
+ (wf_dir / "workflow.yml").write_text(
+ self.WORKFLOW_YAML.format(version="1.0.0"), encoding="utf-8"
+ )
+
+ monkeypatch.setattr(
+ WorkflowCatalog,
+ "get_workflow_info",
+ lambda self, wid: {
+ "id": wid,
+ "name": "Align Workflow",
+ "version": "2.0.0",
+ "url": "https://example.com/workflow.yml",
+ "_install_allowed": True,
+ "_catalog_name": "test-catalog",
+ },
+ )
+ runner = CliRunner()
+ with patch(
+ "specify_cli.authentication.http.open_url",
+ side_effect=lambda url, timeout=None, extra_headers=None, redirect_validator=None: self._FakeResponse(b"", url),
+ ), patch.object(
+ WorkflowDefinition,
+ "from_string",
+ side_effect=ValueError('bad snippet: "New [Feature]"'),
+ ):
+ result = runner.invoke(app, ["workflow", "update"], input="y\n")
+ assert 'bad snippet: "New [Feature]"' in result.output
+ assert "Failed to update" in result.output
+ # The previously installed workflow must survive a failed update.
+ assert "1.0.0" in (wf_dir / "workflow.yml").read_text(encoding="utf-8")
+
+ def test_update_malformed_catalog_url_fails_cleanly(self, project_dir, monkeypatch):
+ """An unparseable catalog URL (unbalanced IPv6 literal) must not abort the whole update."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowCatalog, WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ registry = WorkflowRegistry(project_dir)
+ registry.add("align-wf", {
+ "name": "Align Workflow",
+ "version": "1.0.0",
+ "description": "CLI alignment test workflow",
+ "source": "catalog",
+ "catalog_name": "test-catalog",
+ "url": "https://[::1/workflow.yml",
+ })
+ wf_dir = project_dir / ".specify" / "workflows" / "align-wf"
+ wf_dir.mkdir(parents=True)
+ (wf_dir / "workflow.yml").write_text(
+ self.WORKFLOW_YAML.format(version="1.0.0"), encoding="utf-8"
+ )
+
+ monkeypatch.setattr(
+ WorkflowCatalog,
+ "get_workflow_info",
+ lambda self, wid: {
+ "id": wid,
+ "name": "Align Workflow",
+ "version": "2.0.0",
+ "url": "https://[::1/workflow.yml",
+ "_install_allowed": True,
+ "_catalog_name": "test-catalog",
+ },
+ )
+ runner = CliRunner()
+ result = runner.invoke(app, ["workflow", "update"], input="y\n")
+ assert "malformed install URL" in result.output
+ assert "Failed to update" in result.output
+ # The previously installed workflow must survive.
+ assert "1.0.0" in (wf_dir / "workflow.yml").read_text(encoding="utf-8")
+
+ def test_add_non_string_catalog_url_fails_cleanly(self, project_dir, monkeypatch):
+ """A truthy non-string catalog URL must hit the clean error path, not AttributeError."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowCatalog
+
+ monkeypatch.chdir(project_dir)
+ monkeypatch.setattr(
+ WorkflowCatalog,
+ "get_workflow_info",
+ lambda self, wid: {
+ "id": wid,
+ "name": "Align Workflow",
+ "version": "1.0.0",
+ "url": 123,
+ "_install_allowed": True,
+ "_catalog_name": "test-catalog",
+ },
+ )
+ runner = CliRunner()
+ result = runner.invoke(app, ["workflow", "add", "align-wf"])
+ assert result.exit_code != 0
+ assert result.exception is None or isinstance(result.exception, SystemExit)
+ assert "malformed install URL" in result.output
+
+ def test_enable_failed_save_leaves_workflow_disabled(self, project_dir, monkeypatch):
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ runner = CliRunner()
+ self._install_dev(runner, app, project_dir)
+ result = runner.invoke(app, ["workflow", "disable", "align-wf"])
+ assert result.exit_code == 0, result.output
+
+ def boom(self):
+ raise OSError("disk full")
+
+ with pytest.MonkeyPatch.context() as mp:
+ mp.setattr(WorkflowRegistry, "save", boom)
+ result = runner.invoke(app, ["workflow", "enable", "align-wf"])
+ assert result.exit_code != 0
+
+ assert WorkflowRegistry(project_dir).get("align-wf")["enabled"] is False
+ result = runner.invoke(app, ["workflow", "enable", "align-wf"])
+ assert result.exit_code == 0, result.output
+ assert WorkflowRegistry(project_dir).get("align-wf")["enabled"] is True
+
+ @pytest.mark.parametrize("command", ["enable", "disable"])
+ def test_enable_disable_save_failure_gives_clean_output(
+ self, project_dir, monkeypatch, command
+ ):
+ """A save() failure in enable/disable must produce a clean escaped CLI
+ error, not surface the raw OSError as an unhandled exception. Shared
+ root behavior: both call registry.add() with a fresh mapping and must
+ catch its deliberate OSError the same way."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ runner = CliRunner()
+ self._install_dev(runner, app, project_dir)
+ # disable starts from the enabled default; enable needs a prior disable.
+ starting_enabled = command == "disable"
+ if command == "enable":
+ pre = runner.invoke(app, ["workflow", "disable", "align-wf"])
+ assert pre.exit_code == 0, pre.output
+
+ def boom(self):
+ raise OSError("disk full")
+
+ with pytest.MonkeyPatch.context() as mp:
+ mp.setattr(WorkflowRegistry, "save", boom)
+ result = runner.invoke(app, ["workflow", command, "align-wf"])
+
+ assert result.exit_code != 0
+ assert result.exception is None or isinstance(result.exception, SystemExit)
+ assert result.output.strip() != ""
+ assert (
+ WorkflowRegistry(project_dir).get("align-wf").get("enabled", True)
+ is starting_enabled
+ )
+
+ def test_update_rejects_version_mismatch_from_stale_url(self, project_dir, monkeypatch):
+ """A URL serving a different version than the catalog advertised must fail the update."""
+ from unittest.mock import patch
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowCatalog, WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ WorkflowRegistry(project_dir).add("align-wf", {
+ "name": "Align Workflow",
+ "version": "1.0.0",
+ "description": "CLI alignment test workflow",
+ "source": "catalog",
+ "catalog_name": "test-catalog",
+ "url": "https://example.com/workflow.yml",
+ })
+ wf_dir = project_dir / ".specify" / "workflows" / "align-wf"
+ wf_dir.mkdir(parents=True)
+ (wf_dir / "workflow.yml").write_text(
+ self.WORKFLOW_YAML.format(version="1.0.0"), encoding="utf-8"
+ )
+
+ monkeypatch.setattr(
+ WorkflowCatalog,
+ "get_workflow_info",
+ lambda self, wid: {
+ "id": wid,
+ "name": "Align Workflow",
+ "version": "2.0.0",
+ "url": "https://example.com/workflow.yml",
+ "_install_allowed": True,
+ "_catalog_name": "test-catalog",
+ },
+ )
+ # The URL still serves the old 1.0.0 payload.
+ data = self.WORKFLOW_YAML.format(version="1.0.0").encode()
+ runner = CliRunner()
+ with patch(
+ "specify_cli.authentication.http.open_url",
+ side_effect=lambda url, timeout=None, extra_headers=None, redirect_validator=None: self._FakeResponse(data, url),
+ ):
+ result = runner.invoke(app, ["workflow", "update"], input="y\n")
+ assert "does not match the catalog version" in result.output
+ assert "Failed to update" in result.output
+ meta = WorkflowRegistry(project_dir).get("align-wf")
+ assert meta["version"] == "1.0.0"
+ assert "1.0.0" in (wf_dir / "workflow.yml").read_text(encoding="utf-8")
+
+ def test_update_preserves_disabled_state(self, project_dir, monkeypatch):
+ from unittest.mock import patch
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowCatalog, WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ WorkflowRegistry(project_dir).add("align-wf", {
+ "name": "Align Workflow",
+ "version": "1.0.0",
+ "description": "",
+ "source": "catalog",
+ "url": "https://example.com/workflow.yml",
+ "enabled": False,
+ })
+ monkeypatch.setattr(
+ WorkflowCatalog,
+ "get_workflow_info",
+ lambda self, wid: {
+ "id": wid,
+ "version": "2.0.0",
+ "url": "https://example.com/workflow.yml",
+ "_install_allowed": True,
+ },
+ )
+ data = self.WORKFLOW_YAML.format(version="2.0.0").encode()
+ runner = CliRunner()
+ with patch(
+ "specify_cli.authentication.http.open_url",
+ side_effect=lambda url, timeout=None, extra_headers=None, redirect_validator=None: self._FakeResponse(data, url),
+ ):
+ result = runner.invoke(app, ["workflow", "update"], input="y\n")
+ assert result.exit_code == 0, result.output
+ meta = WorkflowRegistry(project_dir).get("align-wf")
+ assert meta["version"] == "2.0.0"
+ assert meta["enabled"] is False
+
+ @pytest.mark.skipif(os.name == "nt", reason="POSIX permission bits")
+ def test_update_preserves_workflow_file_mode(self, project_dir, monkeypatch):
+ import stat
+ from unittest.mock import patch
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowCatalog, WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ WorkflowRegistry(project_dir).add("align-wf", {
+ "name": "Align Workflow",
+ "version": "1.0.0",
+ "description": "",
+ "source": "catalog",
+ "url": "https://example.com/workflow.yml",
+ })
+ workflow_file = (
+ project_dir
+ / ".specify"
+ / "workflows"
+ / "align-wf"
+ / "workflow.yml"
+ )
+ workflow_file.parent.mkdir(parents=True)
+ workflow_file.write_text(
+ self.WORKFLOW_YAML.format(version="1.0.0"), encoding="utf-8"
+ )
+ workflow_file.chmod(0o640)
+
+ monkeypatch.setattr(
+ WorkflowCatalog,
+ "get_workflow_info",
+ lambda self, wid: {
+ "id": wid,
+ "version": "2.0.0",
+ "url": "https://example.com/workflow.yml",
+ "_install_allowed": True,
+ },
+ )
+ data = self.WORKFLOW_YAML.format(version="2.0.0").encode()
+ with patch(
+ "specify_cli.authentication.http.open_url",
+ side_effect=lambda url, timeout=None, extra_headers=None,
+ redirect_validator=None: self._FakeResponse(data, url),
+ ):
+ result = CliRunner().invoke(
+ app, ["workflow", "update"], input="y\n"
+ )
+
+ assert result.exit_code == 0, result.output
+ assert stat.S_IMODE(workflow_file.stat().st_mode) == 0o640
+
+ def test_update_skips_corrupted_registry_entry(self, project_dir, monkeypatch):
+ import json
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ registry_path = WorkflowRegistry(project_dir).registry_path
+ registry_path.parent.mkdir(parents=True, exist_ok=True)
+ registry_path.write_text(
+ json.dumps({"schema_version": "1.0", "workflows": {"broken": "not-a-dict"}}),
+ encoding="utf-8",
+ )
+ runner = CliRunner()
+ result = runner.invoke(app, ["workflow", "update"])
+ assert result.exit_code == 0, result.output
+ assert "corrupted" in result.output
+
+ def test_list_skips_corrupted_registry_entry(self, project_dir, monkeypatch):
+ import json
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ registry_path = WorkflowRegistry(project_dir).registry_path
+ registry_path.parent.mkdir(parents=True, exist_ok=True)
+ registry_path.write_text(
+ json.dumps(
+ {
+ "schema_version": "1.0",
+ "workflows": {
+ "broken": "not-a-dict",
+ "ok": {"name": "OK Workflow", "version": "1.0.0"},
+ },
+ }
+ ),
+ encoding="utf-8",
+ )
+ runner = CliRunner()
+ result = runner.invoke(app, ["workflow", "list"])
+ assert result.exit_code == 0, result.output
+ assert "corrupted" in result.output
+ assert "OK Workflow" in result.output
+
+ def test_list_unreadable_registry_fails_closed_with_clean_error(
+ self, project_dir, monkeypatch
+ ):
+ """An unreadable registry file must produce a clean CLI error, not a
+ raw traceback and not a silent "nothing installed" list -- the latter
+ is exactly the fail-open state a caller could otherwise mistake for
+ "safe to (re)install", overwriting real files. Covers the read/query
+ boundary fix required at every WorkflowRegistry call site."""
+ import builtins
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ runner = CliRunner()
+ self._install_dev(runner, app, project_dir)
+
+ registry_path = WorkflowRegistry(project_dir).registry_path.resolve()
+ real_open = builtins.open
+
+ def _raising_open(file, mode="r", *args, **kwargs):
+ if Path(file).resolve() == registry_path and "r" in mode:
+ raise OSError("simulated read failure")
+ return real_open(file, mode, *args, **kwargs)
+
+ monkeypatch.setattr(builtins, "open", _raising_open)
+ result = runner.invoke(app, ["workflow", "list"])
+ assert result.exit_code != 0
+ assert result.exception is None or isinstance(result.exception, SystemExit)
+ assert "Error" in result.output
+
+ def test_list_escapes_rich_markup_in_registry_fields(self, project_dir, monkeypatch):
+ """User-editable name/description/id fields must not be parsed as Rich markup."""
+ import json
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ registry_path = WorkflowRegistry(project_dir).registry_path
+ registry_path.parent.mkdir(parents=True, exist_ok=True)
+ registry_path.write_text(
+ json.dumps(
+ {
+ "schema_version": "1.0",
+ "workflows": {
+ "ok": {
+ "name": "Bracket [Test]",
+ "version": "1.0.0",
+ "description": "desc [with] brackets",
+ },
+ },
+ }
+ ),
+ encoding="utf-8",
+ )
+ runner = CliRunner()
+ result = runner.invoke(app, ["workflow", "list"])
+ assert result.exit_code == 0, result.output
+ assert "Bracket [Test]" in result.output
+ assert "desc [with] brackets" in result.output
+
+ def test_update_reports_unsafe_registry_id_per_workflow(self, project_dir, monkeypatch):
+ """An unsafe workflow id in the registry must fail that one entry, not abort the whole update."""
+ import json
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowRegistry, WorkflowCatalog
+
+ monkeypatch.chdir(project_dir)
+ registry_path = WorkflowRegistry(project_dir).registry_path
+ registry_path.parent.mkdir(parents=True, exist_ok=True)
+ registry_path.write_text(
+ json.dumps(
+ {
+ "schema_version": "1.0",
+ "workflows": {
+ "../evil": {
+ "name": "Bad",
+ "version": "0.0.1",
+ "source": "catalog",
+ "url": "https://example.com/evil.yml",
+ },
+ },
+ }
+ ),
+ encoding="utf-8",
+ )
+ monkeypatch.setattr(
+ WorkflowCatalog,
+ "get_workflow_info",
+ lambda self, wid: {"version": "9.9.9", "url": "https://example.com/evil.yml", "_install_allowed": True},
+ )
+ runner = CliRunner()
+ result = runner.invoke(app, ["workflow", "update"], input="y\n")
+ assert result.exit_code != 0
+ assert "Failed to update" in result.output
+
+ def test_update_registry_save_failure_restores_prior_file_without_redundant_write(
+ self, project_dir, monkeypatch
+ ):
+ """A registry.add() save failure during `workflow update` must be
+ fully restored by _install_workflow_from_catalog's own atomic
+ rollback (rename-based, not a byte-level rewrite). The outer
+ workflow_update loop must not perform any redundant write of its
+ own onto the destination file -- that write happened only after
+ typer.Exit already unwound, could itself fail/truncate the safely
+ preserved file, and is provably unnecessary here since the inner
+ transaction already restored it via rename."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowCatalog, WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ monkeypatch.setattr(
+ WorkflowCatalog,
+ "get_workflow_info",
+ lambda self, wid: {
+ "id": wid,
+ "name": "Align Workflow",
+ "version": "1.0.0",
+ "url": "https://example.com/workflow.yml",
+ "_install_allowed": True,
+ "_catalog_name": "test-catalog",
+ },
+ )
+ source_data = self.WORKFLOW_YAML.format(version="1.0.0").encode()
+ runner = CliRunner()
+ with pytest.MonkeyPatch.context() as mp:
+ mp.setattr(
+ "specify_cli.authentication.http.open_url",
+ lambda url, timeout=None, extra_headers=None, redirect_validator=None: self._FakeResponse(
+ source_data, url
+ ),
+ )
+ result = runner.invoke(app, ["workflow", "add", "align-wf"])
+ assert result.exit_code == 0, result.output
+
+ dest_file = project_dir / ".specify" / "workflows" / "align-wf" / "workflow.yml"
+ original_data = dest_file.read_bytes()
+
+ new_data = self.WORKFLOW_YAML.format(version="2.0.0").encode()
+
+ def boom_save(self):
+ raise OSError("disk full")
+
+ dest_writes: list[bytes] = []
+ real_write_bytes = Path.write_bytes
+ resolved_dest_file = dest_file.resolve()
+
+ def tracking_write_bytes(self_path, data, *args, **kwargs):
+ if self_path.resolve() == resolved_dest_file:
+ dest_writes.append(data)
+ return real_write_bytes(self_path, data, *args, **kwargs)
+
+ with pytest.MonkeyPatch.context() as mp:
+ mp.setattr(
+ WorkflowCatalog,
+ "get_workflow_info",
+ lambda self, wid: {
+ "id": wid,
+ "name": "Align Workflow",
+ "version": "2.0.0",
+ "url": "https://example.com/workflow.yml",
+ "_install_allowed": True,
+ "_catalog_name": "test-catalog",
+ },
+ )
+ mp.setattr(
+ "specify_cli.authentication.http.open_url",
+ lambda url, timeout=None, extra_headers=None, redirect_validator=None: self._FakeResponse(
+ new_data, url
+ ),
+ )
+ mp.setattr(WorkflowRegistry, "save", boom_save)
+ mp.setattr(Path, "write_bytes", tracking_write_bytes)
+ result = runner.invoke(app, ["workflow", "update"], input="y\n")
+
+ assert result.exit_code != 0
+ assert "Failed to update" in result.output
+ # No redundant/second write of the destination file was attempted --
+ # the inner atomic commit/rollback (rename-based) is the only thing
+ # that ever touches it.
+ assert dest_writes == []
+ assert dest_file.read_bytes() == original_data
+ registry = WorkflowRegistry(project_dir)
+ assert registry.is_installed("align-wf")
+ assert registry.get("align-wf")["version"] == "1.0.0"
+
+ def test_update_non_json_description_restores_prior_file_and_registry(
+ self, project_dir, monkeypatch
+ ):
+ from unittest.mock import patch
+
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowCatalog, WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ registry = WorkflowRegistry(project_dir)
+ registry.add(
+ "align-wf",
+ {
+ "name": "Align Workflow",
+ "version": "1.0.0",
+ "description": "",
+ "source": "catalog",
+ "url": "https://example.com/workflow.yml",
+ },
+ )
+ workflow_file = (
+ project_dir
+ / ".specify"
+ / "workflows"
+ / "align-wf"
+ / "workflow.yml"
+ )
+ workflow_file.parent.mkdir(parents=True)
+ original_data = self.WORKFLOW_YAML.format(version="1.0.0").encode()
+ workflow_file.write_bytes(original_data)
+
+ monkeypatch.setattr(
+ WorkflowCatalog,
+ "get_workflow_info",
+ lambda self, wid: {
+ "id": wid,
+ "name": "Align Workflow",
+ "version": "2.0.0",
+ "url": "https://example.com/workflow.yml",
+ "_install_allowed": True,
+ "_catalog_name": "test-catalog",
+ },
+ )
+ invalid_data = self.WORKFLOW_YAML.format(version="2.0.0").replace(
+ 'description: "CLI alignment test workflow"',
+ "description: 2026-01-02",
+ ).encode()
+ with patch(
+ "specify_cli.authentication.http.open_url",
+ side_effect=lambda url, timeout=None, extra_headers=None,
+ redirect_validator=None: self._FakeResponse(invalid_data, url),
+ ):
+ result = CliRunner().invoke(
+ app, ["workflow", "update", "align-wf"], input="y\n"
+ )
+
+ assert result.exit_code != 0
+ assert result.exception is None or isinstance(result.exception, SystemExit)
+ assert "Failed to update workflow registry" in result.output
+ assert workflow_file.read_bytes() == original_data
+ current = WorkflowRegistry(project_dir).get("align-wf")
+ assert current["version"] == "1.0.0"
+ leftovers = [
+ path.name
+ for path in workflow_file.parent.iterdir()
+ if path.name != "workflow.yml"
+ ]
+ assert leftovers == []
+
+ def test_commit_failure_reports_unrestored_backup_location(
+ self, tmp_path, monkeypatch
+ ):
+ from specify_cli.workflows import _commands
+
+ dest_dir = tmp_path / "align-wf"
+ dest_dir.mkdir()
+ dest_file = dest_dir / "workflow.yml"
+ staged_file = dest_dir / ".workflow.yml.staged"
+ dest_file.write_text("original", encoding="utf-8")
+ staged_file.write_text("replacement", encoding="utf-8")
+
+ real_replace = os.replace
+ calls = 0
+ backup_file = None
+
+ def fail_commit_and_restore(src, dst):
+ nonlocal backup_file, calls
+ calls += 1
+ if calls == 1:
+ backup_file = Path(dst)
+ return real_replace(src, dst)
+ if calls == 2:
+ raise OSError("commit denied")
+ raise OSError("restore denied")
+
+ monkeypatch.setattr(os, "replace", fail_commit_and_restore)
+ with pytest.raises(OSError) as exc_info:
+ _commands._commit_workflow_file(
+ staged_file, dest_file, existed_before=True
+ )
+
+ message = str(exc_info.value)
+ assert "commit denied" in message
+ assert "restore denied" in message
+ assert backup_file is not None
+ assert str(backup_file) in message
+ assert not dest_file.exists()
+ assert backup_file.read_text(encoding="utf-8") == "original"
+
+ def test_commit_keyboard_interrupt_restores_prior_file(
+ self, tmp_path, monkeypatch
+ ):
+ from specify_cli.workflows import _commands
+
+ dest_dir = tmp_path / "align-wf"
+ dest_dir.mkdir()
+ dest_file = dest_dir / "workflow.yml"
+ staged_file = dest_dir / ".workflow.yml.staged"
+ dest_file.write_text("original", encoding="utf-8")
+ staged_file.write_text("replacement", encoding="utf-8")
+
+ real_replace = os.replace
+ calls = 0
+
+ def interrupt_commit(src, dst):
+ nonlocal calls
+ calls += 1
+ if calls == 2:
+ raise KeyboardInterrupt
+ return real_replace(src, dst)
+
+ monkeypatch.setattr(os, "replace", interrupt_commit)
+ with pytest.raises(KeyboardInterrupt):
+ _commands._commit_workflow_file(
+ staged_file, dest_file, existed_before=True
+ )
+
+ assert dest_file.read_text(encoding="utf-8") == "original"
+ assert staged_file.read_text(encoding="utf-8") == "replacement"
+ assert list(dest_dir.glob("*.bak")) == []
+
+ def test_commit_interrupt_after_first_rename_restores_prior_file(
+ self, tmp_path, monkeypatch
+ ):
+ from specify_cli.workflows import _commands
+
+ dest_dir = tmp_path / "align-wf"
+ dest_dir.mkdir()
+ dest_file = dest_dir / "workflow.yml"
+ staged_file = dest_dir / ".workflow.yml.staged"
+ dest_file.write_text("original", encoding="utf-8")
+ staged_file.write_text("replacement", encoding="utf-8")
+
+ real_replace = os.replace
+ calls = 0
+
+ def interrupt_after_replace(src, dst):
+ nonlocal calls
+ calls += 1
+ result = real_replace(src, dst)
+ if calls == 1:
+ raise KeyboardInterrupt
+ return result
+
+ monkeypatch.setattr(os, "replace", interrupt_after_replace)
+ with pytest.raises(KeyboardInterrupt):
+ _commands._commit_workflow_file(
+ staged_file, dest_file, existed_before=True
+ )
+
+ assert dest_file.read_text(encoding="utf-8") == "original"
+ assert staged_file.read_text(encoding="utf-8") == "replacement"
+ assert list(dest_dir.glob("*.bak")) == []
+
+ def test_commit_uses_unique_backup_without_overwriting_existing_sibling(
+ self, tmp_path
+ ):
+ from specify_cli.workflows import _commands
+
+ dest_dir = tmp_path / "align-wf"
+ dest_dir.mkdir()
+ dest_file = dest_dir / "workflow.yml"
+ staged_file = dest_dir / ".workflow.yml.staged"
+ fixed_backup = dest_dir / "workflow.yml.bak"
+ dest_file.write_text("original", encoding="utf-8")
+ staged_file.write_text("replacement", encoding="utf-8")
+ fixed_backup.write_text("diagnostic copy", encoding="utf-8")
+
+ backup_file = _commands._commit_workflow_file(
+ staged_file, dest_file, existed_before=True
+ )
+
+ assert backup_file is not None
+ assert backup_file != fixed_backup
+ assert backup_file.read_text(encoding="utf-8") == "original"
+ assert fixed_backup.read_text(encoding="utf-8") == "diagnostic copy"
+ assert dest_file.read_text(encoding="utf-8") == "replacement"
+
+ @pytest.mark.parametrize(
+ ("replacement_source", "replacement_version"),
+ [("local", "1.0.0"), ("catalog", "1.5.0")],
+ )
+ def test_update_rechecks_registry_after_confirmation(
+ self, project_dir, monkeypatch, replacement_source, replacement_version
+ ):
+ from unittest.mock import patch
+
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows import _commands
+ from specify_cli.workflows.catalog import WorkflowCatalog, WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ registry = WorkflowRegistry(project_dir)
+ registry.add(
+ "align-wf",
+ {
+ "name": "Align Workflow",
+ "version": "1.0.0",
+ "description": "",
+ "source": "catalog",
+ "url": "https://example.com/workflow.yml",
+ },
+ )
+ workflow_file = (
+ project_dir
+ / ".specify"
+ / "workflows"
+ / "align-wf"
+ / "workflow.yml"
+ )
+ workflow_file.parent.mkdir(parents=True)
+ workflow_file.write_text(
+ self.WORKFLOW_YAML.format(version="1.0.0"), encoding="utf-8"
+ )
+ replacement_data = self.WORKFLOW_YAML.format(
+ version=replacement_version
+ ).replace(
+ 'description: "CLI alignment test workflow"',
+ 'description: "concurrent replacement"',
+ ).encode()
+
+ monkeypatch.setattr(
+ WorkflowCatalog,
+ "get_workflow_info",
+ lambda self, wid: {
+ "id": wid,
+ "name": "Align Workflow",
+ "version": "2.0.0",
+ "url": "https://example.com/workflow.yml",
+ "_install_allowed": True,
+ "_catalog_name": "test-catalog",
+ },
+ )
+
+ def replace_while_confirming(*args, **kwargs):
+ WorkflowRegistry(project_dir).add(
+ "align-wf",
+ {
+ "name": "Concurrent replacement",
+ "version": replacement_version,
+ "description": "",
+ "source": replacement_source,
+ },
+ )
+ workflow_file.write_bytes(replacement_data)
+ return True
+
+ monkeypatch.setattr(_commands.typer, "confirm", replace_while_confirming)
+ catalog_data = self.WORKFLOW_YAML.format(version="2.0.0").encode()
+ with patch(
+ "specify_cli.authentication.http.open_url",
+ side_effect=lambda url, timeout=None, extra_headers=None,
+ redirect_validator=None: self._FakeResponse(catalog_data, url),
+ ):
+ result = CliRunner().invoke(app, ["workflow", "update", "align-wf"])
+
+ assert result.exit_code != 0
+ assert "changed during update" in result.output
+ assert workflow_file.read_bytes() == replacement_data
+ current = WorkflowRegistry(project_dir).get("align-wf")
+ assert current["source"] == replacement_source
+ assert current["version"] == replacement_version
+
+ @pytest.mark.skipif(not hasattr(os, "symlink"), reason="symlinks are unavailable")
+ def test_resume_rejects_symlinked_cross_project_owner_root(
+ self, project_dir, tmp_path
+ ):
+ from specify_cli.workflows import _commands
+
+ real_owner = tmp_path / "real-owner"
+ real_owner.mkdir()
+ owner_link = tmp_path / "owner-link"
+ owner_link.symlink_to(real_owner, target_is_directory=True)
+
+ with pytest.raises(ValueError, match="unavailable"):
+ _commands._resolve_run_owner_root(str(owner_link), project_dir)
+
+ @pytest.mark.skipif(not hasattr(os, "symlink"), reason="symlinks are unavailable")
+ def test_resume_rejects_cross_project_owner_with_symlinked_ancestor(
+ self, project_dir, tmp_path
+ ):
+ from specify_cli.workflows import _commands
+
+ real_parent = tmp_path / "real-parent"
+ owner = real_parent / "owner"
+ owner.mkdir(parents=True)
+ parent_link = tmp_path / "parent-link"
+ parent_link.symlink_to(real_parent, target_is_directory=True)
+
+ with pytest.raises(ValueError, match="unavailable"):
+ _commands._resolve_run_owner_root(
+ str(parent_link / "owner"), project_dir
+ )
+
+ def test_enable_disable_corrupted_registry_entry_errors(self, project_dir, monkeypatch):
+ import json
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ registry_path = WorkflowRegistry(project_dir).registry_path
+ registry_path.parent.mkdir(parents=True, exist_ok=True)
+ registry_path.write_text(
+ json.dumps({"schema_version": "1.0", "workflows": {"broken": "not-a-dict"}}),
+ encoding="utf-8",
+ )
+ runner = CliRunner()
+ for cmd in ("enable", "disable"):
+ result = runner.invoke(app, ["workflow", cmd, "broken"])
+ assert result.exit_code != 0
+ assert "corrupted" in result.output
+
+ def test_update_up_to_date_reports_and_exits_zero(self, project_dir, monkeypatch):
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowCatalog, WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ WorkflowRegistry(project_dir).add("align-wf", {
+ "name": "Align Workflow",
+ "version": "1.0.0",
+ "description": "",
+ "source": "catalog",
+ "url": "https://example.com/workflow.yml",
+ })
+ monkeypatch.setattr(
+ WorkflowCatalog,
+ "get_workflow_info",
+ lambda self, wid: {
+ "id": wid,
+ "version": "1.0.0",
+ "url": "https://example.com/workflow.yml",
+ "_install_allowed": True,
+ },
+ )
+ runner = CliRunner()
+ result = runner.invoke(app, ["workflow", "update"])
+ assert result.exit_code == 0, result.output
+ assert "Up to date" in result.output
+ assert "All workflows are up to date!" in result.output
+
+ def test_update_restores_backup_on_failed_download(self, project_dir, monkeypatch):
+ from unittest.mock import patch
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowCatalog, WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ WorkflowRegistry(project_dir).add("align-wf", {
+ "name": "Align Workflow",
+ "version": "1.0.0",
+ "description": "",
+ "source": "catalog",
+ "url": "https://example.com/workflow.yml",
+ })
+ wf_dir = project_dir / ".specify" / "workflows" / "align-wf"
+ wf_dir.mkdir(parents=True)
+ original = self.WORKFLOW_YAML.format(version="1.0.0")
+ (wf_dir / "workflow.yml").write_text(original, encoding="utf-8")
+
+ monkeypatch.setattr(
+ WorkflowCatalog,
+ "get_workflow_info",
+ lambda self, wid: {
+ "id": wid,
+ "version": "2.0.0",
+ "url": "https://example.com/workflow.yml",
+ "_install_allowed": True,
+ },
+ )
+
+ def boom(url, timeout=None, extra_headers=None, redirect_validator=None):
+ raise OSError("network down")
+
+ runner = CliRunner()
+ with patch("specify_cli.authentication.http.open_url", side_effect=boom):
+ result = runner.invoke(app, ["workflow", "update"], input="y\n")
+ assert result.exit_code != 0
+ assert "Failed to update" in result.output
+ # Working copy and registry version are untouched
+ assert (wf_dir / "workflow.yml").read_text(encoding="utf-8") == original
+ assert WorkflowRegistry(project_dir).get("align-wf")["version"] == "1.0.0"
+
+ # -- enable / disable ------------------------------------------------
+
+ def test_disable_blocks_run_enable_restores(self, project_dir, monkeypatch):
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ runner = CliRunner()
+ self._install_dev(runner, app, project_dir)
+
+ result = runner.invoke(app, ["workflow", "disable", "align-wf"])
+ assert result.exit_code == 0, result.output
+ assert WorkflowRegistry(project_dir).get("align-wf")["enabled"] is False
+
+ result = runner.invoke(app, ["workflow", "run", "align-wf"])
+ assert result.exit_code != 0
+ assert "disabled" in result.output
+
+ result = runner.invoke(app, ["workflow", "enable", "align-wf"])
+ assert result.exit_code == 0, result.output
+ assert WorkflowRegistry(project_dir).get("align-wf")["enabled"] is True
+
+ result = runner.invoke(app, ["workflow", "run", "align-wf"])
+ assert result.exit_code == 0, result.output
+
+ def test_run_rejects_corrupted_registry_entry(self, project_dir, monkeypatch):
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ runner = CliRunner()
+ self._install_dev(runner, app, project_dir)
+
+ registry = WorkflowRegistry(project_dir)
+ registry.data["workflows"]["align-wf"] = "corrupted"
+ registry.save()
+
+ result = runner.invoke(app, ["workflow", "run", "align-wf"])
+ assert result.exit_code != 0
+ assert "corrupted" in result.output
+
+ def test_run_rejects_corrupt_registry_file(self, project_dir, monkeypatch):
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ runner = CliRunner()
+ self._install_dev(runner, app, project_dir)
+
+ registry_path = WorkflowRegistry(project_dir).registry_path
+ registry_path.write_text("not json", encoding="utf-8")
+
+ result = runner.invoke(app, ["workflow", "run", "align-wf"])
+
+ assert result.exit_code != 0
+ assert "registry" in result.output.lower()
+ assert "corrupt" in result.output.lower()
+
+ def test_disable_blocks_case_variant_installed_path(
+ self, project_dir, monkeypatch
+ ):
+ from typer.testing import CliRunner
+ from specify_cli import app
+
+ monkeypatch.chdir(project_dir)
+ runner = CliRunner()
+ self._install_dev(runner, app, project_dir)
+
+ result = runner.invoke(app, ["workflow", "disable", "align-wf"])
+ assert result.exit_code == 0, result.output
+
+ case_variant = (
+ project_dir
+ / ".SPECIFY"
+ / "WORKFLOWS"
+ / "ALIGN-WF"
+ / "workflow.yml"
+ )
+ if not case_variant.is_file():
+ pytest.skip("filesystem is case-sensitive")
+
+ result = runner.invoke(
+ app, ["workflow", "run", str(case_variant)]
+ )
+
+ assert result.exit_code != 0
+ assert "disabled" in result.output
+
+ def test_disable_blocks_run_via_path_equivalent_id(self, project_dir, monkeypatch):
+ """Path-equivalent and newline IDs must not dodge the registry lookup."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+
+ monkeypatch.chdir(project_dir)
+ runner = CliRunner()
+ self._install_dev(runner, app, project_dir)
+
+ result = runner.invoke(app, ["workflow", "disable", "align-wf"])
+ assert result.exit_code == 0, result.output
+
+ for spelling in ("align-wf/", "align-wf/.", "align-wf\n"):
+ result = runner.invoke(app, ["workflow", "run", spelling])
+ assert result.exit_code != 0, spelling
+ assert "Invalid workflow ID" in result.output, spelling
+
+ # Direct path to the installed workflow's own YAML must also refuse.
+ installed_yaml = ".specify/workflows/align-wf/workflow.yml"
+ assert (project_dir / installed_yaml).is_file()
+ result = runner.invoke(app, ["workflow", "run", installed_yaml])
+ assert result.exit_code != 0
+ assert "disabled" in result.output
+
+ # Same guard must hold when invoked from outside the project.
+ outside = project_dir.parent / "outside-cwd"
+ outside.mkdir(exist_ok=True)
+ monkeypatch.chdir(outside)
+ result = runner.invoke(
+ app, ["workflow", "run", str(project_dir / installed_yaml)]
+ )
+ assert result.exit_code != 0
+ assert "disabled" in result.output
+
+ @pytest.mark.skipif(not hasattr(os, "symlink"), reason="symlinks are unavailable")
+ def test_disable_blocks_run_when_installed_yaml_is_symlinked(
+ self, project_dir, monkeypatch
+ ):
+ """A disabled workflow's own workflow.yml being replaced with a symlink
+ must not bypass the disabled check. Resolving the path before mapping
+ it back to its registry owner would follow the symlink out of
+ .specify/workflows, fail to find an owner, and let engine.load_workflow
+ run the original symlink target anyway -- ownership must be
+ determined from the normalized *lexical* path (not resolve()), and a
+ symlinked path component in the installed tree must be refused."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+
+ monkeypatch.chdir(project_dir)
+ runner = CliRunner()
+ self._install_dev(runner, app, project_dir)
+
+ result = runner.invoke(app, ["workflow", "disable", "align-wf"])
+ assert result.exit_code == 0, result.output
+
+ installed_yaml = project_dir / ".specify" / "workflows" / "align-wf" / "workflow.yml"
+ external_target = project_dir / "external-workflow.yml"
+ external_target.write_text(
+ self.WORKFLOW_YAML.format(version="9.9.9"), encoding="utf-8"
+ )
+ installed_yaml.unlink()
+ installed_yaml.symlink_to(external_target)
+
+ result = runner.invoke(app, ["workflow", "run", str(installed_yaml)])
+ assert result.exit_code != 0
+ assert result.exception is None or isinstance(result.exception, SystemExit)
+ assert "disabled" in result.output or "symlink" in result.output.lower()
+
+ @pytest.mark.skipif(not hasattr(os, "symlink"), reason="symlinks are unavailable")
+ def test_alias_rejects_symlinked_workflow_storage_before_resolve(
+ self, project_dir, temp_dir
+ ):
+ import shutil
+ import typer
+ from specify_cli.workflows import _commands
+
+ specify_dir = project_dir / ".specify"
+ shutil.rmtree(specify_dir)
+ redirected = temp_dir / "redirected-storage"
+ workflow_file = redirected / "workflows" / "evil" / "workflow.yml"
+ workflow_file.parent.mkdir(parents=True)
+ workflow_file.write_text(
+ self.WORKFLOW_YAML.format(version="1.0.0"), encoding="utf-8"
+ )
+ specify_dir.symlink_to(redirected, target_is_directory=True)
+ alias = temp_dir / "workflow-alias.yml"
+ alias.symlink_to(
+ project_dir
+ / ".specify"
+ / "workflows"
+ / "evil"
+ / "workflow.yml"
+ )
+
+ with pytest.raises(typer.Exit):
+ _commands._resolve_installed_workflow_ownership(
+ alias, _commands.err_console
+ )
+
+ @pytest.mark.skipif(not hasattr(os, "symlink"), reason="symlinks are unavailable")
+ def test_run_refuses_symlinked_specify_dir_hiding_disabled_workflow(
+ self, temp_dir, monkeypatch
+ ):
+ """A victim project's own .specify directory being a symlink to an
+ attacker-controlled tree must not bypass the disabled-workflow guard.
+ _reject_unsafe_workflow_storage only checks the *cwd's* project root
+ (unrelated here); the id/leaf symlink-component loop only checks
+ components from the id directory onward, missing .specify/
+ .specify/workflows themselves. The ownership check must reject an
+ unsafe .specify/.specify-workflows for the actual path-derived
+ registry root before ever consulting the registry -- it must not
+ rely on WorkflowRegistry's own symlinked-parent handling, which
+ raises a generic OSError; the ownership guard should surface the
+ specific unsafe-storage error before registry construction."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+
+ victim = temp_dir / "victim"
+ victim.mkdir()
+ attacker_real = temp_dir / "attacker-real"
+ (attacker_real / "workflows" / "evil").mkdir(parents=True)
+ (attacker_real / "workflows" / "evil" / "workflow.yml").write_text(
+ self.WORKFLOW_YAML.format(version="1.0.0"), encoding="utf-8"
+ )
+ (attacker_real / "workflows" / "workflow-registry.json").write_text(
+ json.dumps(
+ {
+ "schema_version": "1.0",
+ "workflows": {
+ "evil": {
+ "name": "Evil",
+ "version": "1.0.0",
+ "source": "dev",
+ "enabled": False,
+ }
+ },
+ }
+ ),
+ encoding="utf-8",
+ )
+ (victim / ".specify").symlink_to(attacker_real)
+
+ unrelated_cwd = temp_dir / "unrelated-cwd"
+ unrelated_cwd.mkdir()
+ monkeypatch.chdir(unrelated_cwd)
+
+ runner = CliRunner()
+ target = victim / ".specify" / "workflows" / "evil" / "workflow.yml"
+ result = runner.invoke(app, ["workflow", "run", str(target)])
+ assert result.exit_code != 0
+ assert result.exception is None or isinstance(result.exception, SystemExit)
+ assert "symlink" in result.output.lower()
+
+ def test_run_nested_installed_paths_uses_nearest_owner(
+ self, temp_dir, monkeypatch
+ ):
+ """A direct workflow.yml path whose lexical segments contain
+ .specify/workflows more than once (an unrelated nested project
+ happens to live beneath an outer installed workflow's own
+ directory tree, reusing the same segment names) must be attributed
+ to its *nearest* (innermost) owning project/ID -- scanning from the
+ start of the path and stopping at the first match would pick the
+ outer project and the wrong workflow ID, gating the run on an
+ unrelated workflow's disabled state instead of the real owner's."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+
+ def _write_registry(workflows_dir, workflow_id, enabled):
+ workflows_dir.mkdir(parents=True, exist_ok=True)
+ (workflows_dir / "workflow-registry.json").write_text(
+ json.dumps(
+ {
+ "schema_version": "1.0",
+ "workflows": {
+ workflow_id: {
+ "name": workflow_id,
+ "version": "1.0.0",
+ "source": "dev",
+ "enabled": enabled,
+ }
+ },
+ }
+ ),
+ encoding="utf-8",
+ )
+
+ outer_workflows = temp_dir / "outer-proj" / ".specify" / "workflows"
+ outer_wf_dir = outer_workflows / "outer-wf"
+ outer_wf_dir.mkdir(parents=True)
+ (outer_wf_dir / "workflow.yml").write_text(
+ self.WORKFLOW_YAML.format(version="1.0.0"), encoding="utf-8"
+ )
+ _write_registry(outer_workflows, "outer-wf", enabled=False)
+
+ # An unrelated nested project lives inside the outer workflow's own
+ # directory tree, with its own separate installed workflow.
+ inner_workflows = outer_wf_dir / "nested-proj" / ".specify" / "workflows"
+ inner_wf_dir = inner_workflows / "inner-wf"
+ inner_wf_dir.mkdir(parents=True)
+ (inner_wf_dir / "workflow.yml").write_text(
+ self.WORKFLOW_YAML.format(version="1.0.0"), encoding="utf-8"
+ )
+ _write_registry(inner_workflows, "inner-wf", enabled=True)
+
+ unrelated_cwd = temp_dir / "unrelated-cwd"
+ unrelated_cwd.mkdir()
+ monkeypatch.chdir(unrelated_cwd)
+
+ runner = CliRunner()
+ target = inner_wf_dir / "workflow.yml"
+ result = runner.invoke(app, ["workflow", "run", str(target)])
+ # inner-wf (the actual nearest owner) is enabled -- must run, not
+ # be blocked by the unrelated outer-wf's disabled state.
+ assert result.exit_code == 0, result.output
+
+ # The inverse proves this isn't just ignoring nesting: disabling
+ # the true (nearest) owner must actually block this exact path.
+ _write_registry(inner_workflows, "inner-wf", enabled=False)
+ result = runner.invoke(app, ["workflow", "run", str(target)])
+ assert result.exit_code != 0
+ assert "disabled" in result.output
+
+ @pytest.mark.skipif(not hasattr(os, "symlink"), reason="symlinks are unavailable")
+ def test_run_blocks_disabled_workflow_via_outward_alias_symlink(
+ self, project_dir, monkeypatch
+ ):
+ """The inverse of the existing inward-symlink case: a path with no
+ .specify/workflows segments at all (e.g. /tmp/alias.yml) that is
+ itself a symlink resolving *into* installed storage must still
+ receive the disabled check. Only checking the lexical path's own
+ segments misses this alias entirely, since it has no such segments
+ to begin with, and would let engine.load_workflow follow the
+ symlink to the disabled workflow's real content unchecked."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+
+ monkeypatch.chdir(project_dir)
+ runner = CliRunner()
+ self._install_dev(runner, app, project_dir)
+
+ result = runner.invoke(app, ["workflow", "disable", "align-wf"])
+ assert result.exit_code == 0, result.output
+
+ installed_yaml = (
+ project_dir / ".specify" / "workflows" / "align-wf" / "workflow.yml"
+ )
+ external_dir = project_dir / "outside-alias"
+ external_dir.mkdir()
+ alias = external_dir / "alias.yml"
+ alias.symlink_to(installed_yaml)
+
+ result = runner.invoke(app, ["workflow", "run", str(alias)])
+ assert result.exit_code != 0
+ assert "disabled" in result.output
+
+ result = runner.invoke(app, ["workflow", "enable", "align-wf"])
+ assert result.exit_code == 0, result.output
+ result = runner.invoke(app, ["workflow", "run", str(alias)])
+ assert result.exit_code == 0, result.output
+
+ _GATED_WORKFLOW_YAML = """
+schema_version: "1.0"
+workflow:
+ id: "gated-wf"
+ name: "Gated Workflow"
+ version: "1.0.0"
+steps:
+ - id: ask
+ type: gate
+ message: "Review"
+ options: [approve, reject]
+"""
+
+ def _install_and_run_gated(self, runner, app, project_dir):
+ """Install a gate-step workflow and run it to a paused state.
+
+ Returns the run_id. The gate step pauses without any interactive
+ input, giving a resumable run tied to an installed workflow ID.
+ """
+ src = project_dir / "gated-src"
+ src.mkdir(exist_ok=True)
+ (src / "workflow.yml").write_text(self._GATED_WORKFLOW_YAML, encoding="utf-8")
+ result = runner.invoke(app, ["workflow", "add", str(src), "--dev"])
+ assert result.exit_code == 0, result.output
+
+ result = runner.invoke(app, ["workflow", "run", "gated-wf", "--json"])
+ assert result.exit_code == 0, result.output
+ payload = json.loads(result.stdout)
+ assert payload["status"] == "paused"
+ return payload["run_id"]
+
+ def test_unregistered_workflow_shaped_path_is_not_persisted_as_owner(
+ self, project_dir, temp_dir, monkeypatch
+ ):
+ """A direct file is not installed merely because its path resembles
+ installed storage; only registry membership establishes ownership."""
+ import shutil
+ from typer.testing import CliRunner
+ from specify_cli import app
+
+ standalone_root = temp_dir / "standalone-project"
+ workflows_dir = standalone_root / ".specify" / "workflows"
+ workflow_file = workflows_dir / "gated-wf" / "workflow.yml"
+ workflow_file.parent.mkdir(parents=True)
+ workflow_file.write_text(self._GATED_WORKFLOW_YAML, encoding="utf-8")
+
+ monkeypatch.chdir(project_dir)
+ runner = CliRunner()
+ run_ids = []
+ for _ in range(2):
+ result = runner.invoke(
+ app, ["workflow", "run", str(workflow_file), "--json"]
+ )
+ assert result.exit_code == 0, result.output
+ run_ids.append(json.loads(result.stdout)["run_id"])
+
+ for run_id in run_ids:
+ state_path = (
+ project_dir
+ / ".specify"
+ / "workflows"
+ / "runs"
+ / run_id
+ / "state.json"
+ )
+ state = json.loads(state_path.read_text(encoding="utf-8"))
+ assert state["installed_workflow_id"] is None
+ assert state["installed_registry_root"] is None
+
+ shutil.rmtree(standalone_root)
+ result = runner.invoke(
+ app, ["workflow", "resume", run_ids[0], "--json"]
+ )
+ assert result.exit_code == 0, result.output
+
+ workflows_dir.mkdir(parents=True)
+ (workflows_dir / "workflow-registry.json").write_text(
+ json.dumps(
+ {
+ "schema_version": "1.0",
+ "workflows": {
+ "gated-wf": {
+ "name": "Unrelated workflow",
+ "version": "9.9.9",
+ "source": "dev",
+ "enabled": False,
+ }
+ },
+ }
+ ),
+ encoding="utf-8",
+ )
+ result = runner.invoke(
+ app, ["workflow", "resume", run_ids[1], "--json"]
+ )
+ assert result.exit_code == 0, result.output
+
+ def test_resume_blocks_when_installed_workflow_disabled(
+ self, project_dir, monkeypatch
+ ):
+ """A run started from an installed workflow must not resume once
+ that workflow is disabled. engine.resume() replays the persisted
+ run directly from disk with no registry awareness at all, so the
+ installed workflow's origin (id + owning registry root) is
+ persisted at run start and re-checked against the registry's
+ *current* state before resuming, mirroring `workflow run`'s
+ disabled guard."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+
+ monkeypatch.chdir(project_dir)
+ runner = CliRunner()
+ run_id = self._install_and_run_gated(runner, app, project_dir)
+
+ result = runner.invoke(app, ["workflow", "disable", "gated-wf"])
+ assert result.exit_code == 0, result.output
+
+ result = runner.invoke(app, ["workflow", "resume", run_id])
+ assert result.exit_code != 0
+ assert "disabled" in result.output
+
+ # Re-enabling must unblock the exact same run.
+ result = runner.invoke(app, ["workflow", "enable", "gated-wf"])
+ assert result.exit_code == 0, result.output
+ result = runner.invoke(app, ["workflow", "resume", run_id, "--json"])
+ assert result.exit_code == 0, result.output
+ resumed = json.loads(result.stdout)
+ assert resumed["run_id"] == run_id
+
+ def test_resume_rejects_corrupted_registry_entry(
+ self, project_dir, monkeypatch
+ ):
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.catalog import WorkflowRegistry
+
+ monkeypatch.chdir(project_dir)
+ runner = CliRunner()
+ run_id = self._install_and_run_gated(runner, app, project_dir)
+
+ registry = WorkflowRegistry(project_dir)
+ registry.data["workflows"]["gated-wf"] = "corrupted"
+ registry.save()
+
+ result = runner.invoke(app, ["workflow", "resume", run_id])
+ assert result.exit_code != 0
+ assert "corrupted" in result.output
+
+ def test_resume_preload_io_error_is_reported_cleanly(
+ self, project_dir, monkeypatch
+ ):
+ from unittest.mock import patch
+ from typer.testing import CliRunner
+ from specify_cli import app
+ from specify_cli.workflows.engine import RunState
+
+ monkeypatch.chdir(project_dir)
+ with patch.object(
+ RunState, "load", side_effect=OSError("permission [denied]")
+ ):
+ result = CliRunner().invoke(
+ app, ["workflow", "resume", "unreadable-run"]
+ )
+
+ assert result.exit_code != 0
+ assert result.exception is None or isinstance(result.exception, SystemExit)
+ assert "Resume failed" in result.output
+ assert "permission [denied]" in result.output
+
+ @pytest.mark.parametrize("malformation", ["non-object", "missing-run-id"])
+ def test_resume_preload_rejects_malformed_state_cleanly(
+ self, project_dir, monkeypatch, malformation
+ ):
+ from typer.testing import CliRunner
+ from specify_cli import app
+
+ monkeypatch.chdir(project_dir)
+ runner = CliRunner()
+ run_id = self._install_and_run_gated(runner, app, project_dir)
+ state_path = (
+ project_dir / ".specify" / "workflows" / "runs" / run_id / "state.json"
+ )
+
+ if malformation == "non-object":
+ state_path.write_text("[]", encoding="utf-8")
+ else:
+ data = json.loads(state_path.read_text(encoding="utf-8"))
+ data.pop("run_id")
+ state_path.write_text(json.dumps(data), encoding="utf-8")
+
+ result = runner.invoke(app, ["workflow", "resume", run_id])
+
+ assert result.exit_code != 0
+ assert result.exception is None or isinstance(result.exception, SystemExit)
+ assert "Invalid run state" in result.output
+
+ def test_resume_legacy_run_respects_current_disabled_state(
+ self, project_dir, monkeypatch
+ ):
+ """Legacy runs infer same-project registry ownership before resume."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+
+ monkeypatch.chdir(project_dir)
+ runner = CliRunner()
+ run_id = self._install_and_run_gated(runner, app, project_dir)
+
+ state_path = (
+ project_dir / ".specify" / "workflows" / "runs" / run_id / "state.json"
+ )
+ data = json.loads(state_path.read_text(encoding="utf-8"))
+ data.pop("installed_workflow_id", None)
+ data.pop("installed_registry_root", None)
+ state_path.write_text(json.dumps(data), encoding="utf-8")
+
+ result = runner.invoke(app, ["workflow", "disable", "gated-wf"])
+ assert result.exit_code == 0, result.output
+
+ result = runner.invoke(app, ["workflow", "resume", run_id, "--json"])
+ assert result.exit_code != 0
+ assert "disabled" in result.output
+
+ def test_resume_migrates_legacy_installed_origin_metadata(
+ self, project_dir, monkeypatch
+ ):
+ from typer.testing import CliRunner
+ from specify_cli import app
+
+ monkeypatch.chdir(project_dir)
+ runner = CliRunner()
+ run_id = self._install_and_run_gated(runner, app, project_dir)
+
+ state_path = (
+ project_dir / ".specify" / "workflows" / "runs" / run_id / "state.json"
+ )
+ data = json.loads(state_path.read_text(encoding="utf-8"))
+ data.pop("installed_workflow_id", None)
+ data.pop("installed_registry_root", None)
+ state_path.write_text(json.dumps(data), encoding="utf-8")
+
+ result = runner.invoke(app, ["workflow", "resume", run_id, "--json"])
+ assert result.exit_code == 0, result.output
+
+ migrated = json.loads(state_path.read_text(encoding="utf-8"))
+ assert migrated["installed_workflow_id"] == "gated-wf"
+ assert migrated["installed_registry_root"] is None
+
+ def test_resume_blocks_after_project_moved_following_disable(
+ self, temp_dir, monkeypatch
+ ):
+ """Renaming/moving the entire project after starting a run must not
+ let a subsequent disable-then-resume bypass the guard. Persisting
+ the run's *creation-time absolute* project path would make resume
+ open a now-nonexistent old root (WorkflowRegistry falls back to an
+ empty default there), missing the disabled entry that actually
+ lives in the *current* (moved) project's registry. The common,
+ same-project case must instead re-derive the owning root from the
+ project's current location on every resume."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+ import shutil
+
+ project_v1 = temp_dir / "project-v1"
+ (project_v1 / ".specify" / "workflows").mkdir(parents=True)
+ monkeypatch.chdir(project_v1)
+ runner = CliRunner()
+ run_id = self._install_and_run_gated(runner, app, project_v1)
+
+ project_v2 = temp_dir / "project-v2"
+ monkeypatch.chdir(temp_dir)
+ shutil.move(str(project_v1), str(project_v2))
+ monkeypatch.chdir(project_v2)
+
+ result = runner.invoke(app, ["workflow", "disable", "gated-wf"])
+ assert result.exit_code == 0, result.output
+
+ result = runner.invoke(app, ["workflow", "resume", run_id])
+ assert result.exit_code != 0
+ assert "disabled" in result.output
+
+ def test_resume_after_project_moved_still_works_when_enabled(
+ self, temp_dir, monkeypatch
+ ):
+ """The inverse of the move regression: an enabled workflow's run
+ must still resume normally after the project is moved -- the
+ current-project fallback must not itself block legitimate
+ resumes."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+ import shutil
+
+ project_v1 = temp_dir / "project-v1-ok"
+ (project_v1 / ".specify" / "workflows").mkdir(parents=True)
+ monkeypatch.chdir(project_v1)
+ runner = CliRunner()
+ run_id = self._install_and_run_gated(runner, app, project_v1)
+
+ project_v2 = temp_dir / "project-v2-ok"
+ monkeypatch.chdir(temp_dir)
+ shutil.move(str(project_v1), str(project_v2))
+ monkeypatch.chdir(project_v2)
+
+ result = runner.invoke(app, ["workflow", "resume", run_id, "--json"])
+ assert result.exit_code == 0, result.output
+
+ @pytest.mark.skipif(not hasattr(os, "symlink"), reason="symlinks are unavailable")
+ def test_resume_respects_cross_project_registry_root(
+ self, temp_dir, monkeypatch
+ ):
+ """A run started via a direct workflow.yml path belonging to a
+ different project than the cwd used for `workflow run`/`workflow
+ resume` must still gate resuming on *that* owning project's
+ registry, not the cwd project's (which has no entry for this ID
+ at all). This is the genuine cross-project case that must remain
+ unaffected by only special-casing the common same-project one."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+
+ owner_project = temp_dir / "owner-project"
+ (owner_project / ".specify" / "workflows").mkdir(parents=True)
+ monkeypatch.chdir(owner_project)
+ runner = CliRunner()
+ src = owner_project / "gated-src"
+ src.mkdir()
+ (src / "workflow.yml").write_text(self._GATED_WORKFLOW_YAML, encoding="utf-8")
+ result = runner.invoke(app, ["workflow", "add", str(src), "--dev"])
+ assert result.exit_code == 0, result.output
+
+ unrelated_cwd = temp_dir / "unrelated-cwd"
+ unrelated_cwd.mkdir()
+ monkeypatch.chdir(unrelated_cwd)
+
+ owner_alias = temp_dir / "owner-project-alias"
+ owner_alias.symlink_to(owner_project, target_is_directory=True)
+ target = owner_alias / ".specify" / "workflows" / "gated-wf" / "workflow.yml"
+ result = runner.invoke(app, ["workflow", "run", str(target), "--json"])
+ assert result.exit_code == 0, result.output
+ run_id = json.loads(result.stdout)["run_id"]
+ state_path = (
+ unrelated_cwd
+ / ".specify"
+ / "workflows"
+ / "runs"
+ / run_id
+ / "state.json"
+ )
+ state = json.loads(state_path.read_text(encoding="utf-8"))
+ assert state["installed_registry_root"] == str(owner_project.resolve())
+
+ monkeypatch.chdir(owner_project)
+ result = runner.invoke(app, ["workflow", "disable", "gated-wf"])
+ assert result.exit_code == 0, result.output
+
+ # Resume must run from unrelated_cwd (where this run's own
+ # state.json actually lives) yet still be blocked by the owner
+ # project's disabled entry.
+ monkeypatch.chdir(unrelated_cwd)
+ result = runner.invoke(app, ["workflow", "resume", run_id])
+ assert result.exit_code != 0
+ assert "disabled" in result.output
+
+ def test_resume_rejects_missing_cross_project_owner_root(
+ self, temp_dir, monkeypatch
+ ):
+ """A vanished explicit cross-project owner cannot be safely
+ rediscovered, so resume must fail closed instead of consulting the
+ unrelated project that stores the run state."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+ import shutil
+
+ owner_project = temp_dir / "owner-project-2"
+ (owner_project / ".specify" / "workflows").mkdir(parents=True)
+ monkeypatch.chdir(owner_project)
+ runner = CliRunner()
+ src = owner_project / "gated-src"
+ src.mkdir()
+ (src / "workflow.yml").write_text(self._GATED_WORKFLOW_YAML, encoding="utf-8")
+ result = runner.invoke(app, ["workflow", "add", str(src), "--dev"])
+ assert result.exit_code == 0, result.output
+
+ unrelated_cwd = temp_dir / "unrelated-cwd-2"
+ unrelated_cwd.mkdir()
+ monkeypatch.chdir(unrelated_cwd)
+
+ target = owner_project / ".specify" / "workflows" / "gated-wf" / "workflow.yml"
+ result = runner.invoke(app, ["workflow", "run", str(target), "--json"])
+ assert result.exit_code == 0, result.output
+ run_id = json.loads(result.stdout)["run_id"]
+
+ # owner_project vanishes entirely -- its persisted absolute root
+ # is now dangling.
+ shutil.rmtree(owner_project)
+
+ result = runner.invoke(app, ["workflow", "resume", run_id])
+ assert result.exit_code != 0
+ assert "owner" in result.output.lower()
+ assert "unavailable" in result.output.lower()
+
+ @pytest.mark.parametrize(
+ "field, bad_value",
+ [
+ ("installed_workflow_id", 123),
+ ("installed_workflow_id", ["gated-wf"]),
+ ("installed_workflow_id", {"id": "gated-wf"}),
+ ("installed_workflow_id", True),
+ ("installed_workflow_id", ""),
+ ("installed_workflow_id", "gated-wf\n"),
+ ("installed_registry_root", 123),
+ ("installed_registry_root", ["."]),
+ ("installed_registry_root", {"root": "."}),
+ ("installed_registry_root", False),
+ ("installed_registry_root", ""),
+ ("installed_registry_root", "relative-owner"),
+ ],
+ )
+ def test_resume_rejects_malformed_run_state_origin_fields(
+ self, project_dir, monkeypatch, field, bad_value
+ ):
+ """RunState.load() rejects malformed or unsafe origin metadata
+ before registry/path lookups and reports a clean CLI error."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+
+ monkeypatch.chdir(project_dir)
+ runner = CliRunner()
+ run_id = self._install_and_run_gated(runner, app, project_dir)
+
+ state_path = (
+ project_dir / ".specify" / "workflows" / "runs" / run_id / "state.json"
+ )
+ data = json.loads(state_path.read_text(encoding="utf-8"))
+ data[field] = bad_value
+ state_path.write_text(json.dumps(data), encoding="utf-8")
+
+ result = runner.invoke(app, ["workflow", "resume", run_id])
+ assert result.exit_code != 0
+ assert result.exception is None or isinstance(result.exception, SystemExit)
+ assert "Error" in result.output
+
+ @pytest.mark.parametrize("command", ["resume", "status"])
+ def test_state_load_errors_escape_rich_markup(
+ self, project_dir, monkeypatch, command
+ ):
+ from typer.testing import CliRunner
+ from specify_cli import app
+
+ monkeypatch.chdir(project_dir)
+ runner = CliRunner()
+ run_id = self._install_and_run_gated(runner, app, project_dir)
+
+ state_path = (
+ project_dir / ".specify" / "workflows" / "runs" / run_id / "state.json"
+ )
+ data = json.loads(state_path.read_text(encoding="utf-8"))
+ malicious_status = "[bold red]forged[/bold red]"
+ data["status"] = malicious_status
+ state_path.write_text(json.dumps(data), encoding="utf-8")
+
+ result = runner.invoke(app, ["workflow", command, run_id])
+
+ assert result.exit_code != 0
+ assert malicious_status in result.output
+
+ @pytest.mark.parametrize(
+ "installed_workflow_id, installed_registry_root",
+ [
+ (None, None),
+ ("gated-wf", None),
+ ],
+ )
+ def test_resume_accepts_valid_run_state_origin_fields(
+ self, project_dir, monkeypatch, installed_workflow_id, installed_registry_root
+ ):
+ """Valid installed-origin values continue to load and resume."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+
+ monkeypatch.chdir(project_dir)
+ runner = CliRunner()
+ run_id = self._install_and_run_gated(runner, app, project_dir)
+
+ state_path = (
+ project_dir / ".specify" / "workflows" / "runs" / run_id / "state.json"
+ )
+ data = json.loads(state_path.read_text(encoding="utf-8"))
+ data["installed_workflow_id"] = installed_workflow_id
+ data["installed_registry_root"] = installed_registry_root
+ state_path.write_text(json.dumps(data), encoding="utf-8")
+
+ result = runner.invoke(app, ["workflow", "resume", run_id, "--json"])
+ assert result.exit_code == 0, result.output
+
+ @pytest.mark.parametrize(
+ "field, bad_value",
+ [
+ ("installed_workflow_id", 123),
+ ("installed_workflow_id", ["gated-wf"]),
+ ("installed_registry_root", 123),
+ ("installed_registry_root", ["."]),
+ ],
+ )
+ def test_status_rejects_malformed_run_state_origin_fields(
+ self, project_dir, monkeypatch, field, bad_value
+ ):
+ """`workflow status <run_id>` calls RunState.load() same as resume,
+ but only caught FileNotFoundError -- the new type validation there
+ (int/list instead of str-or-null) raises ValueError, which leaked
+ as a raw unhandled traceback instead of `workflow resume`'s clean
+ `[red]Error:[/red] {exc}` + exit 1. Must get the identical clean
+ boundary, leaving the no-run-id list path (and FileNotFoundError
+ behavior) unchanged."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+
+ monkeypatch.chdir(project_dir)
+ runner = CliRunner()
+ run_id = self._install_and_run_gated(runner, app, project_dir)
+
+ state_path = (
+ project_dir / ".specify" / "workflows" / "runs" / run_id / "state.json"
+ )
+ data = json.loads(state_path.read_text(encoding="utf-8"))
+ data[field] = bad_value
+ state_path.write_text(json.dumps(data), encoding="utf-8")
+
+ result = runner.invoke(app, ["workflow", "status", run_id])
+ assert result.exit_code != 0
+ assert result.exception is None or isinstance(result.exception, SystemExit)
+ assert "Error" in result.output
+
+ def test_status_run_not_found_unchanged(self, project_dir, monkeypatch):
+ """FileNotFoundError behavior for a nonexistent run_id must remain
+ exactly as before this fix."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+
+ monkeypatch.chdir(project_dir)
+ (project_dir / ".specify" / "workflows").mkdir(parents=True, exist_ok=True)
+ runner = CliRunner()
+ result = runner.invoke(app, ["workflow", "status", "nonexistent-run"])
+ assert result.exit_code != 0
+ assert "Run not found: nonexistent-run" in result.output
+
+ def test_status_no_run_id_list_path_unaffected(self, project_dir, monkeypatch):
+ """The no-run-id list-all-runs path must remain unaffected by the
+ new single-run ValueError boundary."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+
+ monkeypatch.chdir(project_dir)
+ (project_dir / ".specify" / "workflows").mkdir(parents=True, exist_ok=True)
+ runner = CliRunner()
+ result = runner.invoke(app, ["workflow", "status"])
+ assert result.exit_code == 0, result.output
+
+ def test_disable_shows_marker_in_list(self, project_dir, monkeypatch):
+ from typer.testing import CliRunner
+ from specify_cli import app
+
+ monkeypatch.chdir(project_dir)
+ runner = CliRunner()
+ self._install_dev(runner, app, project_dir)
+ runner.invoke(app, ["workflow", "disable", "align-wf"])
+ result = runner.invoke(app, ["workflow", "list"])
+ assert result.exit_code == 0, result.output
+ assert "[disabled]" in result.output
+
+ def test_enable_disable_not_installed_errors(self, project_dir, monkeypatch):
+ from typer.testing import CliRunner
+ from specify_cli import app
+
+ monkeypatch.chdir(project_dir)
+ runner = CliRunner()
+ for cmd in ("enable", "disable"):
+ result = runner.invoke(app, ["workflow", cmd, "ghost"])
+ assert result.exit_code != 0
+ assert "not installed" in result.output
+
+ def test_enable_disable_idempotent_warnings(self, project_dir, monkeypatch):
+ from typer.testing import CliRunner
+ from specify_cli import app
+
+ monkeypatch.chdir(project_dir)
+ runner = CliRunner()
+ self._install_dev(runner, app, project_dir)
+
+ result = runner.invoke(app, ["workflow", "enable", "align-wf"])
+ assert result.exit_code == 0
+ assert "already enabled" in result.output
+
+ runner.invoke(app, ["workflow", "disable", "align-wf"])
+ result = runner.invoke(app, ["workflow", "disable", "align-wf"])
+ assert result.exit_code == 0
+ assert "already disabled" in result.output