cortexapps-cli 1.33.0__tar.gz → 1.35.0__tar.gz

{cortexapps_cli-1.33.0 → cortexapps_cli-1.35.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cortexapps-cli
-Version: 1.33.0
+Version: 1.35.0
 Summary: Command Line Interface for cortexapps
 License: MIT
 License-File: LICENSE

{cortexapps_cli-1.33.0 → cortexapps_cli-1.35.0}/cortexapps_cli/cli.py

@@ -39,6 +39,7 @@ import cortexapps_cli.commands.packages as packages
 import cortexapps_cli.commands.plugins as plugins
 import cortexapps_cli.commands.queries as queries
 import cortexapps_cli.commands.rest as rest
+import cortexapps_cli.commands.scaffolders as scaffolders
 import cortexapps_cli.commands.scim as scim
 import cortexapps_cli.commands.scorecards as scorecards
 import cortexapps_cli.commands.secrets as secrets
@@ -277,6 +278,7 @@ app.add_typer(packages.app, name="packages")
 app.add_typer(plugins.app, name="plugins")
 app.add_typer(queries.app, name="queries")
 app.add_typer(rest.app, name="rest")
+app.add_typer(scaffolders.app, name="scaffolders")
 app.add_typer(scim.app, name="scim")
 app.add_typer(scorecards.app, name="scorecards")
 app.add_typer(secrets.app, name="secrets")

cortexapps_cli-1.35.0/cortexapps_cli/commands/scaffolders.py

@@ -0,0 +1,156 @@
+from cortexapps_cli.command_options import CommandOptions
+from cortexapps_cli.command_options import ListCommandOptions
+from cortexapps_cli.utils import print_output_with_context, print_output
+from typing_extensions import Annotated
+import json
+import typer
+import yaml
+
+app = typer.Typer(
+    help="Scaffolder template commands",
+    no_args_is_help=True
+)
+
+def _is_valid_yaml(filepath):
+    try:
+        yaml.safe_load(filepath)
+        filepath.seek(0)
+        return True
+    except yaml.YAMLError:
+        return False
+
+def _is_valid_json(filepath):
+    try:
+        json.load(filepath)
+        filepath.seek(0)
+        return True
+    except json.JSONDecodeError:
+        return False
+
+def _read_definition(file_input):
+    if _is_valid_json(file_input):
+        content_type = "application/json"
+        data = json.loads("".join([line for line in file_input]))
+    elif _is_valid_yaml(file_input):
+        data = file_input.read()
+        content_type = "application/yaml"
+    else:
+        raise typer.BadParameter("Input file is neither valid JSON nor YAML.")
+    return data, content_type
+
+@app.command()
+def list(
+    ctx: typer.Context,
+    _print: CommandOptions._print = True,
+    page: ListCommandOptions.page = None,
+    page_size: ListCommandOptions.page_size = 250,
+    table_output: ListCommandOptions.table_output = False,
+    csv_output: ListCommandOptions.csv_output = False,
+    columns: ListCommandOptions.columns = [],
+    no_headers: ListCommandOptions.no_headers = False,
+    filters: ListCommandOptions.filters = [],
+    sort: ListCommandOptions.sort = [],
+):
+    """
+    List Scaffolder templates.
+    """
+
+    client = ctx.obj["client"]
+
+    params = {
+       "page": page,
+       "pageSize": page_size
+    }
+
+    if (table_output or csv_output) and not ctx.params.get('columns'):
+        ctx.params['columns'] = [
+            "Tag=tag",
+            "Name=name",
+            "Description=description",
+        ]
+
+    # remove any params that are None
+    params = {k: v for k, v in params.items() if v is not None}
+
+    if page is None:
+        # if page is not specified, we want to fetch all pages
+        r = client.fetch("api/v1/scaffolders", params=params)
+    else:
+        # if page is specified, we want to fetch only that page
+        r = client.get("api/v1/scaffolders", params=params)
+
+    if _print:
+        print_output_with_context(ctx, r)
+    else:
+        return(r)
+
+@app.command()
+def get(
+    ctx: typer.Context,
+    tag: str = typer.Option(..., "--tag", "-t", help="The tag or unique, auto-generated Cortex ID of the Scaffolder template"),
+    yaml: bool = typer.Option(False, "--yaml", "-y", help="When true, returns the YAML representation of the template."),
+    _print: CommandOptions._print = True,
+):
+    """
+    Retrieve Scaffolder template by tag or Cortex ID.
+    """
+
+    client = ctx.obj["client"]
+
+    if yaml:
+        headers={'Accept': 'application/yaml'}
+    else:
+        headers={'Accept': 'application/json'}
+    r = client.get("api/v1/scaffolders/" + tag, headers=headers)
+
+    if _print:
+        if yaml:
+           print(r)
+        else:
+           print_output_with_context(ctx, r)
+    else:
+        return(r)
+
+@app.command()
+def create(
+    ctx: typer.Context,
+    file_input: Annotated[typer.FileText, typer.Option(..., "--file", "-f", help="File containing the Scaffolder template definition; can be passed as stdin with -, example: -f-")],
+):
+    """
+    Create or update a Scaffolder template.  API key must have the Configure Scaffolder permission.  Note: If a Scaffolder template with the same tag already exists, it will be updated.
+    """
+
+    client = ctx.obj["client"]
+
+    data, content_type = _read_definition(file_input)
+    r = client.post("api/v1/scaffolders", data=data, content_type=content_type)
+    print_output(r)
+
+@app.command()
+def update(
+    ctx: typer.Context,
+    tag: Annotated[str, typer.Option(..., "--tag", "-t", help="The tag or unique, auto-generated Cortex ID of the Scaffolder template")],
+    file_input: Annotated[typer.FileText, typer.Option(..., "--file", "-f", help="File containing the Scaffolder template definition; can be passed as stdin with -, example: -f-")],
+):
+    """
+    Update a Scaffolder template by tag or Cortex ID.  API key must have the Configure Scaffolder permission.
+    """
+
+    client = ctx.obj["client"]
+
+    data, content_type = _read_definition(file_input)
+    r = client.put("api/v1/scaffolders/" + tag, data=data, content_type=content_type)
+    print_output(r)
+
+@app.command()
+def delete(
+    ctx: typer.Context,
+    tag: str = typer.Option(..., "--tag", "-t", help="The tag or unique, auto-generated Cortex ID of the Scaffolder template"),
+):
+    """
+    Delete Scaffolder template by tag or Cortex ID.  API key must have the Configure Scaffolder permission.
+    """
+
+    client = ctx.obj["client"]
+
+    r = client.delete("api/v1/scaffolders/" + tag)

{cortexapps_cli-1.33.0 → cortexapps_cli-1.35.0}/cortexapps_cli/commands/solutions.py

@@ -223,8 +223,8 @@ def _get_setup_description(solution_tag: str, solutions_dir: str | None = None)
     """Return the SETUP_DESCRIPTION from a solution's setup.py, or a generic fallback."""
     module = _load_setup_module(solution_tag, solutions_dir)
     if module:
-        return getattr(module, "SETUP_DESCRIPTION", "This solution includes a post-install setup script.")
-    return "This solution includes a post-install setup script."
+        return getattr(module, "SETUP_DESCRIPTION", "This solution includes a setup script.")
+    return "This solution includes a setup script."
 
 
 def _run_post_install_script(solution_tag: str, solutions_dir: str | None = None, ctx=None, no_prompt: bool = False) -> None:
@@ -700,7 +700,7 @@ def install(
             if failed_m:
                 typer.echo(failed_m.group(0))
             typer.echo(f"\n  {total_imported} imported, {total_failed} failed")
-        else:
+        elif total_imported > 0:
             typer.echo(f"  {total_imported} entities imported")
     else:
         typer.echo(output)

{cortexapps_cli-1.33.0 → cortexapps_cli-1.35.0}/cortexapps_cli/solutions/_lib/setup_base.py

@@ -139,6 +139,11 @@ class SolutionSetup(ABC):
         self._state[key] = True
         self._save_file()
 
+    def mark_undone(self, key: str) -> None:
+        """Clear a step's completion state (e.g., after the underlying resource is deleted)."""
+        self._state.pop(key, None)
+        self._save_file()
+
     @abstractmethod
     def collect_prompts(self) -> None:
         """Collect all user inputs upfront before executing steps."""

{cortexapps_cli-1.33.0 → cortexapps_cli-1.35.0}/cortexapps_cli/solutions/github-actions-deploy/setup.py

@@ -5,7 +5,7 @@ Run via: cortex solutions post-install -s github-actions-deploy
 """
 
 SETUP_DESCRIPTION = (
-    "This solution includes a post-install setup script that will create a GitHub "
+    "This solution includes a setup script that will create a GitHub "
     "repository, seed it with a GitHub workflow that will add a deploy to a Cortex entity, and configure the required secrets."
 )
 import base64
@@ -172,8 +172,6 @@ class GitHubActionsSetup(SolutionSetup):
 
         if self._session_base_url:
             self._answers["cortex_base_url"] = self._session_base_url
-        else:
-            self.prompt("cortex_base_url", "Cortex base URL", default=self._session_base_url)
         else:
             self.prompt(
                 "cortex_base_url",

{cortexapps_cli-1.33.0 → cortexapps_cli-1.35.0}/cortexapps_cli/solutions/harness-deploy/setup.py

@@ -6,7 +6,7 @@ Run via: cortex solutions post-install -s harness-deploy
 """
 
 SETUP_DESCRIPTION = (
-    "This solution includes a post-install setup script that will configure your Harness "
+    "This solution includes a setup script that will configure your Harness "
     "integration in Cortex, create the deploy pipeline and cortex_api_key secret in Harness, "
     "import the Cortex trigger workflow, and optionally fire a test deploy."
 )

cortexapps_cli-1.35.0/cortexapps_cli/solutions/workday/README.md

@@ -0,0 +1,137 @@
+---
+name: Workday Integration
+description: Configure the Cortex Workday integration with a sample org hierarchy from the fictional company Pied Piper (from the TV show Silicon Valley) to sync employees and teams into your service catalog.
+---
+
+# Workday Integration
+
+Get the Cortex Workday integration running in minutes using a sample org hierarchy from the fictional company Pied Piper (from the TV show *Silicon Valley*). After install, trigger a sync to see employees and teams appear in your catalog — including the full team hierarchy.
+
+## Data Model
+
+```
+  ┌──────────────────────┐     ┌──────────────────────┐     ┌──────────────────────┐
+  │   Workday Report     │────▶│  Cortex Integration  │────▶│   Team Catalog       │
+  │   (JSON / RaaS)      │     │   (field mapping)    │     │   + Members          │
+  └──────────────────────┘     └──────────────────────┘     └──────────────────────┘
+
+  Sample: Pied Piper supervisory org (Silicon Valley)
+
+  PP: Pied Piper (Erlich Bachman)
+  ├── PP: Engineering (Richard Hendricks)
+  │   ├── PP: Platform (Bertram Gilfoyle)
+  │   │   └── PP: Infrastructure (Nelson Bighetti)
+  │   └── PP: Frontend (Dinesh Chugtai)
+  └── PP: Operations (Jared Dunn)
+      └── PP: People Ops (Monica Hall)
+
+  Report Format
+  ─────────────
+  Each entry represents one employee. Workteam_Group lists the employee's teams.
+  Hierarchy is encoded as parentTeamId → teamName. Root teams use "NONE".
+  Managers have Team_Managed set to their team's teamName.
+
+  {
+    "Report_Entry": [
+      {
+        "Email": "erlich.bachman@piedpiper.com",
+        "Employee_ID": "PP-100000",
+        "First_Name": "Erlich",
+        "Last_Name": "Bachman",
+        "Managers_Email": "erlich.bachman@piedpiper.com",
+        "employeeRole": "CEO",
+        "Workteam_Group": [
+          {
+            "teamName": "PP: Pied Piper",
+            "teamDisplayName": "PP: Pied Piper",
+            "parentTeamId": "NONE",
+            "Team_Managed": "PP: Pied Piper"
+          }
+        ]
+      },
+      ...
+    ]
+  }
+
+  Field Mapping (data/configuration.json)
+  ────────────────────────────────────────
+  Maps report columns to employee fields, team identity, and hierarchy.
+  Workday reports can be customized — the configuration defines the field
+  attributes and the hierarchy, so it works with any supervisory org report.
+
+  {
+    "ownershipReportUrl": "<your-report-url>",
+    "reportMappingV2": {
+      "email":        { "columnName": "Email" },
+      "employeeId":   { "columnName": "Employee_ID" },
+      "firstName":    { "columnName": "First_Name" },
+      "lastName":     { "columnName": "Last_Name" },
+      "employeeRole": { "columnName": "employeeRole" },
+      "teamListFields": {
+        "teamListKey": { "columnName": "Workteam_Group" },
+        "teamId":      { "columnName": "teamName" },
+        "teamName":    { "columnName": "teamDisplayName" },
+        "hierarchy": {
+          "fieldOnParentNode": { "columnName": "teamName" },
+          "fieldOnChildNode":  { "columnName": "parentTeamId" }
+        },
+        "teamEmployeeManages": { "columnName": "Team_Managed" }
+      },
+      "type": "ONE_EMPLOYEE_MULTIPLE_TEAMS"
+    }
+  }
+```
+
+## After Installing
+
+Trigger the sync in Cortex to import the Pied Piper org hierarchy:
+
+**Catalog → All Entities → Import Entities → Workday → Sync Entities → Next Step**
+
+You should see 7 teams appear in your catalog with the full hierarchy:
+
+```
+PP: Pied Piper (Erlich Bachman)
+├── PP: Engineering (Richard Hendricks)
+│   ├── PP: Platform (Bertram Gilfoyle)
+│   │   └── PP: Infrastructure (Nelson Bighetti)
+│   └── PP: Frontend (Dinesh Chugtai)
+└── PP: Operations (Jared Dunn)
+    └── PP: People Ops (Monica Hall)
+```
+
+Workday reports can be customized to match your org structure. The configuration defines which report columns map to employee fields, team identity, and the parent-child hierarchy — so the integration works with any supervisory org report that follows the same shape.
+
+## What's Included
+
+- **Pied Piper org data:** 7 employees across 4 levels of hierarchy (Erlich → Richard → Gilfoyle/Dinesh, Jared → Monica, Gilfoyle → Big Head)
+- **Integration config:** field mapping and report URL pre-configured, pointing at the hosted data
+- **Setup script:** one-command configuration of the Cortex Workday integration via API
+
+## Quick Start
+
+1. Install the solution:
+
+   ```
+   cortex solutions install -s workday
+   ```
+
+2. Follow the post-install setup prompts, or run later:
+
+   ```
+   cortex solutions post-install -s workday
+   ```
+
+3. Trigger the import in Cortex:
+
+   **Catalog → All Entities → Import Entities → Workday → Sync Entities → Next Step**
+
+4. Check your team hierarchy to see the Pied Piper org chart.
+
+## How It Works
+
+The setup script calls the Cortex Workday integration API to configure a report URL pointing at the bundled Pied Piper supervisory org data. Cortex fetches the report and syncs employees and teams into your catalog on the next import run.
+
+## Adapting to Real Workday Data
+
+To connect your own Workday report, go to **Settings → Integrations → Workday** in the Cortex UI and update the Report URL, username, and password. The field mapping in `data/configuration.json` works unchanged for any Workday supervisory org report that uses the same column names.

cortexapps_cli-1.35.0/cortexapps_cli/solutions/workday/data/configuration.json

@@ -0,0 +1,31 @@
+{
+  "username": "ISU_Cortex",
+  "ownershipReportUrl": "https://jeff-test-org.github.io/workday-mocks/pied-piper-supervisory-org",
+  "reportMappingV2": {
+    "email": { "columnName": "Email" },
+    "employeeId": { "columnName": "Employee_ID" },
+    "firstName": { "columnName": "First_Name" },
+    "lastName": { "columnName": "Last_Name" },
+    "managerEmail": null,
+    "employeeRole": { "columnName": "employeeRole" },
+    "rootTeams": [],
+    "teamListFields": {
+      "teamListKey": { "columnName": "Workteam_Group" },
+      "teamId": { "columnName": "teamName" },
+      "teamName": { "columnName": "teamDisplayName" },
+      "hierarchy": {
+        "fieldOnChildNode": { "columnName": "parentTeamId" },
+        "fieldOnParentNode": { "columnName": "teamName", "isList": false }
+      },
+      "teamEmployeeManages": { "columnName": "Team_Managed" }
+    },
+    "fallbackFields": {
+      "teamId": null,
+      "teamName": null,
+      "fieldOnParentNode": null,
+      "fieldOnChildNode": null
+    },
+    "type": "ONE_EMPLOYEE_MULTIPLE_TEAMS"
+  },
+  "password": "asdf"
+}

cortexapps_cli-1.35.0/cortexapps_cli/solutions/workday/data/pied-piper-supervisory-org.json

@@ -0,0 +1,113 @@
+{
+  "Report_Entry": [
+    {
+      "Email": "erlich.bachman@piedpiper.com",
+      "Employee_ID": "PP-100000",
+      "First_Name": "Erlich",
+      "Last_Name": "Bachman",
+      "Managers_Email": "erlich.bachman@piedpiper.com",
+      "employeeRole": "CEO",
+      "Workteam_Group": [
+        {
+          "teamName": "PP: Pied Piper",
+          "teamDisplayName": "PP: Pied Piper",
+          "parentTeamId": "NONE",
+          "Team_Managed": "PP: Pied Piper"
+        }
+      ]
+    },
+    {
+      "Email": "richard.hendricks@piedpiper.com",
+      "Employee_ID": "PP-100001",
+      "First_Name": "Richard",
+      "Last_Name": "Hendricks",
+      "Managers_Email": "erlich.bachman@piedpiper.com",
+      "employeeRole": "CTO",
+      "Workteam_Group": [
+        {
+          "teamName": "PP: Engineering",
+          "teamDisplayName": "PP: Engineering",
+          "parentTeamId": "PP: Pied Piper",
+          "Team_Managed": "PP: Engineering"
+        }
+      ]
+    },
+    {
+      "Email": "bertram.gilfoyle@piedpiper.com",
+      "Employee_ID": "PP-100002",
+      "First_Name": "Bertram",
+      "Last_Name": "Gilfoyle",
+      "Managers_Email": "richard.hendricks@piedpiper.com",
+      "employeeRole": "Staff Engineer",
+      "Workteam_Group": [
+        {
+          "teamName": "PP: Platform",
+          "teamDisplayName": "PP: Platform",
+          "parentTeamId": "PP: Engineering",
+          "Team_Managed": "PP: Platform"
+        }
+      ]
+    },
+    {
+      "Email": "dinesh.chugtai@piedpiper.com",
+      "Employee_ID": "PP-100003",
+      "First_Name": "Dinesh",
+      "Last_Name": "Chugtai",
+      "Managers_Email": "richard.hendricks@piedpiper.com",
+      "employeeRole": "Senior Engineer",
+      "Workteam_Group": [
+        {
+          "teamName": "PP: Frontend",
+          "teamDisplayName": "PP: Frontend",
+          "parentTeamId": "PP: Engineering"
+        }
+      ]
+    },
+    {
+      "Email": "jared.dunn@piedpiper.com",
+      "Employee_ID": "PP-100004",
+      "First_Name": "Jared",
+      "Last_Name": "Dunn",
+      "Managers_Email": "erlich.bachman@piedpiper.com",
+      "employeeRole": "COO",
+      "Workteam_Group": [
+        {
+          "teamName": "PP: Operations",
+          "teamDisplayName": "PP: Operations",
+          "parentTeamId": "PP: Pied Piper",
+          "Team_Managed": "PP: Operations"
+        }
+      ]
+    },
+    {
+      "Email": "monica.hall@piedpiper.com",
+      "Employee_ID": "PP-100005",
+      "First_Name": "Monica",
+      "Last_Name": "Hall",
+      "Managers_Email": "jared.dunn@piedpiper.com",
+      "employeeRole": "VP People",
+      "Workteam_Group": [
+        {
+          "teamName": "PP: People Ops",
+          "teamDisplayName": "PP: People Ops",
+          "parentTeamId": "PP: Operations"
+        }
+      ]
+    },
+    {
+      "Email": "nelson.bighetti@piedpiper.com",
+      "Employee_ID": "PP-100006",
+      "First_Name": "Nelson",
+      "Last_Name": "Bighetti",
+      "Managers_Email": "bertram.gilfoyle@piedpiper.com",
+      "employeeRole": "Engineer",
+      "Workteam_Group": [
+        {
+          "teamName": "PP: Infrastructure",
+          "teamDisplayName": "PP: Infrastructure",
+          "parentTeamId": "PP: Platform"
+        }
+      ]
+    }
+  ]
+}

cortexapps_cli-1.35.0/cortexapps_cli/solutions/workday/setup.py

@@ -0,0 +1,145 @@
+"""
+Post-install setup script for the workday solution.
+Configures the Cortex Workday integration to sync the Pied Piper org hierarchy.
+Run via: cortex solutions post-install -s workday
+"""
+
+SETUP_DESCRIPTION = (
+    "This solution includes a setup script that will configure "
+    "the Cortex Workday integration to sync the Pied Piper org hierarchy."
+)
+
+import json
+import sys
+from pathlib import Path
+import requests
+
+try:
+    from cortexapps_cli.solutions._lib.setup_base import SolutionSetup
+except ImportError:
+    sys.path.insert(0, str(Path(__file__).parent.parent.parent))
+    from _lib.setup_base import SolutionSetup
+
+DATA_DIR = Path(__file__).parent / "data"
+CONFIG_FILE = DATA_DIR / "configuration.json"
+
+
+class WorkdayIntegrationSetup(SolutionSetup):
+    solution_tag = "workday"
+
+    def __init__(
+        self,
+        cortex_api_key: str = None,
+        cortex_base_url: str = None,
+        no_prompt: bool = False,
+        **kwargs,
+    ):
+        super().__init__(no_prompt=no_prompt, **kwargs)
+        self._api_key = cortex_api_key or ""
+        self._base_url = (cortex_base_url or "https://api.getcortexapp.com").rstrip("/")
+
+    def _cortex_headers(self) -> dict:
+        return {
+            "Authorization": f"Bearer {self._api_key}",
+            "Content-Type": "application/json",
+        }
+
+    def collect_prompts(self) -> None:
+        pass  # credentials come from CLI session
+
+    def _check_and_replace_existing(self) -> None:
+        """Check for an existing Workday config; backup and delete it if user confirms."""
+        r = requests.get(
+            f"{self._base_url}/api/v1/workday/default-configuration",
+            headers=self._cortex_headers(),
+        )
+        if r.status_code == 404:
+            self.mark_undone("configure")  # no integration on server — reconfigure regardless of cached state
+            return
+        r.raise_for_status()
+
+        if not self.confirm("Existing Workday integration found. Replace it?", default=False):
+            print("Keeping existing Workday integration. Exiting.")
+            raise SystemExit(0)
+
+        # Back up the existing config
+        backup_dir = Path.home() / ".cortex" / "solutions" / "workday"
+        backup_dir.mkdir(parents=True, exist_ok=True)
+        backup_file = backup_dir / "backup-config.json"
+        backup_file.write_text(json.dumps(r.json(), indent=2))
+        print(f"  Backed up existing config to {backup_file}")
+
+        # Delete the existing config
+        del_r = requests.delete(
+            f"{self._base_url}/api/v1/workday/configurations",
+            headers=self._cortex_headers(),
+        )
+        del_r.raise_for_status()
+        self.mark_undone("configure")
+
+    def _configure_integration(self) -> None:
+        """POST the bundled Workday integration configuration."""
+        if self.already_done("configure"):
+            return "Already configured (skipped)"
+        config = json.loads(CONFIG_FILE.read_text())
+        print(f"  (cortex integrations workday add -f {CONFIG_FILE})")
+        r = requests.post(
+            f"{self._base_url}/api/v1/workday/configuration",
+            headers=self._cortex_headers(),
+            json=config,
+        )
+        if not r.ok:
+            raise RuntimeError(
+                f"Failed to configure Workday integration: {r.status_code} {r.text}"
+            )
+        self.mark_done("configure")
+
+    def _validate_integration(self) -> None:
+        """Validate the Workday integration configuration."""
+        print(f"  (cortex integrations workday validate)")
+        r = requests.post(
+            f"{self._base_url}/api/v1/workday/configuration/validate",
+            headers=self._cortex_headers(),
+        )
+        r.raise_for_status()
+        configs = r.json().get("configurations", [])
+        if not configs:
+            raise RuntimeError("Validation returned no results — is the integration configured?")
+        result = configs[0]
+        if not result.get("isValid", False):
+            raise RuntimeError(f"Validation failed: {result.get('message', 'unknown error')}")
+        print(f"  ✓ Configuration validated successfully")
+
+    def _enable_auto_import(self) -> None:
+        """Prompt user to enable Auto Import Workday Teams in Cortex settings."""
+        print("  In Cortex: Settings → Entities → Teams → Enable 'Auto import Workday teams'")
+        if not self.confirm("  Is 'Auto import Workday teams' enabled?", default=False):
+            print("Please enable it before continuing.")
+            raise SystemExit(0)
+
+    def steps(self) -> list:
+        return [
+            ("Enable Auto Import Workday teams", self._enable_auto_import),
+            ("Check for existing Workday integration", self._check_and_replace_existing),
+            ("Configure Workday integration", self._configure_integration),
+            ("Validate Workday integration", self._validate_integration),
+        ]
+
+    def post_steps(self) -> None:
+        print("\n✓ Workday integration configured with the Pied Piper org hierarchy.\n")
+        print("Next: trigger a sync in Cortex:")
+        print("  Catalog → All Entities → Import Entities → Workday")
+        print("  Click 'Sync Entities', then 'Next Step' to import.\n")
+        print("Then check your team hierarchy to see the Pied Piper org chart.")
+
+
+def main(cortex_api_key=None, cortex_base_url=None, no_prompt=False, **kwargs):
+    WorkdayIntegrationSetup(
+        cortex_api_key=cortex_api_key,
+        cortex_base_url=cortex_base_url,
+        no_prompt=no_prompt,
+    ).run()
+
+
+if __name__ == "__main__":
+    main()

{cortexapps_cli-1.33.0 → cortexapps_cli-1.35.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "cortexapps-cli"
 # version will be incremented via command line as part of github actions build
-version = "1.33.0"
+version = "1.35.0"
 description = "Command Line Interface for cortexapps"
 license = "MIT"
 authors = [