spaceforge 0.1.0.dev0__py3-none-any.whl → 1.0.0__py3-none-any.whl

spaceforge/plugin.py

@@ -9,7 +9,8 @@ import os
 import subprocess
 import urllib.request
 from abc import ABC
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any, Dict, List, Optional, Tuple
+from urllib.error import HTTPError
 
 
 class SpaceforgePlugin(ABC):
@@ -31,29 +32,41 @@ class SpaceforgePlugin(ABC):
     __author__ = "Spacelift Team"
 
     def __init__(self) -> None:
+        self._run_id = os.environ.get("TF_VAR_spacelift_run_id", "local")
+        self._is_local = self._run_id == "local"
         self.logger = self._setup_logger()
+        self.spacelift_domain = os.environ.get(
+            "TF_VAR_spacelift_graphql_endpoint", ""
+        ).replace("/graphql", "")
 
-        self._api_token = os.environ.get("SPACELIFT_API_TOKEN", False)
-        self._spacelift_domain = os.environ.get(
-            "TF_VAR_spacelift_graphql_endpoint", False
+        self._api_token = os.environ.get("SPACELIFT_API_TOKEN") or False
+        self._api_endpoint = (
+            os.environ.get("TF_VAR_spacelift_graphql_endpoint") or False
         )
-        self._api_enabled = self._api_token != False and self._spacelift_domain != False
-        self._workspace_root = os.environ.get("WORKSPACE_ROOT", os.getcwd())
+        self._api_enabled = bool(self._api_token and self._api_endpoint)
+        self._workspace_root = os.getcwd()
+        self._spacelift_markdown_endpoint = None
+        self._markdown_endpoint_token = os.environ.get("SPACELIFT_API_TOKEN") or False
 
         # This should be the last thing we do in the constructor
         # because we set api_enabled to false if the domain is set up incorrectly.
-        if self._spacelift_domain and isinstance(self._spacelift_domain, str):
+        if self._api_endpoint and isinstance(self._api_endpoint, str):
             # this must occur after we check if spacelift domain is false
             # because the domain could be set but not start with https://
-            if self._spacelift_domain.startswith("https://"):
-                if self._spacelift_domain.endswith("/"):
-                    self._spacelift_domain = self._spacelift_domain[:-1]
+            if self._api_endpoint.startswith("https://"):
+                if self._api_endpoint.endswith("/"):
+                    self._api_endpoint = self._api_endpoint[:-1]
             else:
                 self.logger.warning(
                     "SPACELIFT_DOMAIN does not start with https://, api calls will fail."
                 )
                 self._api_enabled = False
 
+            if self._api_enabled:
+                self._spacelift_markdown_endpoint = self._api_endpoint.replace(
+                    "/graphql", "/worker/plugin_logs_url"
+                )
+
     def _setup_logger(self) -> logging.Logger:
         """Set up logging for the plugin."""
 
@@ -62,7 +75,7 @@ class SpaceforgePlugin(ABC):
         warn_color = "\033[33m"
         error_color = "\033[31m"
         end_color = "\033[0m"
-        run_id = os.environ.get("TF_VAR_spacelift_run_id", "local")
+        run_id = self._run_id
         plugin_name = self.__plugin_name__
 
         class ColorFormatter(logging.Formatter):
@@ -93,13 +106,62 @@ class SpaceforgePlugin(ABC):
             handler.setFormatter(ColorFormatter())
 
         # Always check for debug mode spacelift variable
-        if os.environ.get("SPACELIFT_DEBUG"):
+        if os.environ.get("SPACELIFT_DEBUG") or self._is_local:
             logger.setLevel(logging.DEBUG)
         else:
             logger.setLevel(logging.INFO)
 
         return logger
 
+    def use_user_token(self, id: str, token: str) -> None:
+        headers = {"Content-Type": "application/json"}
+
+        query = """
+        mutation requestApiKey($id: ID!, $secret: String!){
+          apiKeyUser(id: $id, secret: $secret){
+            jwt
+          }
+        }
+        """
+
+        data: Dict[str, Any] = {
+            "query": query,
+            "variables": {"id": id, "secret": token},
+        }
+
+        req = urllib.request.Request(
+            self._api_endpoint,  # type: ignore[arg-type]
+            json.dumps(data).encode("utf-8"),
+            headers,
+        )
+
+        self.logger.debug(f"Sending request to url: {self._api_endpoint}")
+        try:
+            with urllib.request.urlopen(req) as response:
+                resp: Dict[str, Any] = json.loads(response.read().decode("utf-8"))
+        except urllib.error.HTTPError as e:
+            if hasattr(e, "read"):
+                resp = json.loads(e.read().decode("utf-8"))
+            else:
+                # We should not get here, but if we do re-raise the exception
+                self.logger.error(f"HTTP error occurred: ({e.code}) {e.reason} {e.msg}")
+                raise e
+
+        if "errors" in resp:
+            self.logger.error(f"Error: {resp['errors']}")
+            return
+
+        if (
+            "data" in resp
+            and "apiKeyUser" in resp["data"]
+            and "jwt" in resp["data"]["apiKeyUser"]
+        ):
+            self._api_token = resp["data"]["apiKeyUser"]["jwt"]
+            self._api_enabled = True
+            self.logger.debug("Successfully set user token for API calls.")
+        else:
+            self.logger.error(f"API call returned no data: {resp}")
+
     def get_available_hooks(self) -> List[str]:
         """
         Get list of hook methods available in this plugin.
@@ -136,9 +198,7 @@ class SpaceforgePlugin(ABC):
         Run a CLI command with the given arguments.
 
         Args:
-            command: The command to run
-            *args: Positional arguments for the command
-            **kwargs: Keyword arguments for the command
+            *command: The command to run
             expect_code: Expected return code
             print_output: Whether to print the output to the logger
         """
@@ -175,7 +235,7 @@ class SpaceforgePlugin(ABC):
     ) -> Dict[str, Any]:
         if not self._api_enabled:
             self.logger.error(
-                'API is not enabled, please export "SPACELIFT_API_TOKEN" and "SPACELIFT_DOMAIN".'
+                'API is not enabled, please export "SPACELIFT_API_TOKEN" and "TF_VAR_spacelift_graphql_endpoint".'
             )
             exit(1)
 
@@ -192,12 +252,22 @@ class SpaceforgePlugin(ABC):
             data["variables"] = variables
 
         req = urllib.request.Request(
-            f"{self._spacelift_domain}/graphql",
+            self._api_endpoint,  # type: ignore[arg-type]
             json.dumps(data).encode("utf-8"),
             headers,
         )
-        with urllib.request.urlopen(req) as response:
-            resp: Dict[str, Any] = json.loads(response.read().decode("utf-8"))
+
+        self.logger.debug(f"Sending request to url: {self._api_endpoint}")
+        try:
+            with urllib.request.urlopen(req) as response:
+                resp: Dict[str, Any] = json.loads(response.read().decode("utf-8"))
+        except urllib.error.HTTPError as e:
+            if hasattr(e, "read"):
+                resp = json.loads(e.read().decode("utf-8"))
+            else:
+                # We should not get here, but if we do re-raise the exception
+                self.logger.error(f"HTTP error occurred: ({e.code}) {e.reason} {e.msg}")
+                raise e
 
         if "errors" in resp:
             self.logger.error(f"Error: {resp['errors']}")
@@ -225,9 +295,116 @@ class SpaceforgePlugin(ABC):
             data: Dict[str, Any] = json.load(f)
             return data
 
-    def send_markdown(self, markdown: str) -> None:
-        # TODO
-        print(markdown)
+    def send_markdown(self, markdown: str) -> bool:
+        """
+        Send a markdown message to the Spacelift run.
+
+        Args:
+            markdown: The markdown content to send
+        """
+        if self._is_local:
+            self.logger.info(
+                "Spacelift run is local. Not uploading markdown. Below is a preview of what would be sent"
+            )
+            self.logger.info(markdown)
+            return True
+
+        if (
+            self._spacelift_markdown_endpoint is None
+            or not self._markdown_endpoint_token
+        ):
+            self.logger.error(
+                'API is not enabled, please export "SPACELIFT_API_TOKEN" and "TF_VAR_spacelift_graphql_endpoint".'
+            )
+            return False
+
+        headers = {"Authorization": f"Bearer {self._markdown_endpoint_token}"}
+        body = {
+            "plugin_name": self.__plugin_name__,
+        }
+
+        # First we get the signed url for uploading
+        req = urllib.request.Request(
+            self._spacelift_markdown_endpoint,
+            json.dumps(body).encode("utf-8"),
+            headers,
+            method="POST",
+        )
+
+        self.logger.debug(
+            f"Sending request to url: {self._spacelift_markdown_endpoint}"
+        )
+        try:
+            with urllib.request.urlopen(req) as response:
+                if response.status != 200:
+                    self.logger.error(
+                        f"Error getting signed URL for markdown upload: {response}"
+                    )
+                    return False
+
+                raw_response = response.read().decode("utf-8")
+                self.logger.debug(raw_response)
+                resp: Dict[str, Any] = json.loads(raw_response)
+                if "url" not in resp or "headers" not in resp:
+                    self.logger.error(
+                        "Markdown signed url response does not contain 'url' or 'headers' key."
+                    )
+                    return False
+
+                signed_url = resp["url"]
+                headers = resp["headers"]
+                headers["Content-Type"] = "text/markdown"
+                headers["Content-Length"] = str(len(markdown.encode("utf-8")))
+        except HTTPError as e:
+            self.logger.error(f"HTTP error occurred: ({e.code}) {e.reason} {e.msg}")
+            return False
+
+        self.logger.debug("Markdown to send" + markdown)
+
+        # Now we upload the markdown content to the signed URL
+        req = urllib.request.Request(
+            signed_url,
+            data=markdown.encode("utf-8"),
+            headers=headers,
+            method="PUT",
+        )
+
+        self.logger.debug(f"Sending request to url: {signed_url}")
+        try:
+            with urllib.request.urlopen(req) as put_response:
+                if put_response.status != 200:
+                    self.logger.error(
+                        f"Error uploading markdown content: {put_response.status}"
+                    )
+                    return False
+                self.logger.debug("Markdown content uploaded successfully.")
+        except HTTPError as e:
+            self.logger.error(
+                f"HTTP error occurred during upload: ({e.code}) {e.reason} {e.msg}"
+            )
+            return False
+
+        return True
+
+    def add_to_policy_input(self, input_name: str, data: Dict[str, Any]) -> None:
+        """
+        Add data to the policy input for the current Spacelift run.
+
+        Args:
+            input_name: The name of the input to add (will be available as input.third_party_metadata.custom.{input_name} to the policy).
+            data: Dictionary containing data to add to the policy input
+        """
+        if self._is_local:
+            self.logger.info(
+                "Spacelift run is local. Not writing custom policy input. Below is a preview of what would be written"
+            )
+            self.logger.info(json.dumps(data, indent=2))
+            return
+
+        with open(
+            f"{self._workspace_root}/{input_name}.custom.spacelift.json", "w"
+        ) as f:
+            f.write(json.dumps(data))
 
     # Hook methods - override these in your plugin
     def before_init(self) -> None:

spaceforge/runner.py

@@ -4,7 +4,6 @@ Plugin runner for executing hook methods.
 
 import importlib.util
 import os
-import sys
 from typing import Optional
 
 
@@ -102,14 +101,3 @@ def runner_command(hook_name: str, plugin_file: str) -> None:
     """
     runner = PluginRunner(plugin_file)
     runner.run_hook(hook_name)
-
-
-def main() -> None:
-    """Legacy main entry point for backward compatibility."""
-    if len(sys.argv) != 2:
-        print("Usage: python -m spaceforge.runner <hook_name>")
-        sys.exit(1)
-
-    hook_name = sys.argv[1]
-    runner = PluginRunner()
-    runner.run_hook(hook_name)

spaceforge/schema.json

@@ -1,7 +1,7 @@
 {
   "$defs": {
     "Context": {
-      "description": "A class to represent a context for a plugin.\n\nAttributes:\n    name_prefix (str): The name of the context, will be appended with a unique ID.\n    description (str): A description of the context.\n    labels (dict): Labels associated with the context.\n    env (list): List of variables associated with the context.\n    hooks (dict): Hooks associated with the context.",
+      "description": "A class to represent a context for a plugin.\n\nAttributes:\n    name_prefix (str): The name of the context, will be appended with a unique ID.\n    description (str): A description of the context.\n    labels (Optional[List[str]]): Labels associated with the context.\n    env (list): List of variables associated with the context.\n    hooks (dict): Hooks associated with the context.",
       "properties": {
         "name_prefix": {
           "title": "Name Prefix",
@@ -74,10 +74,10 @@
         "labels": {
           "anyOf": [
             {
-              "additionalProperties": {
+              "items": {
                 "type": "string"
               },
-              "type": "object"
+              "type": "array"
             },
             {
               "type": "null"
@@ -118,7 +118,7 @@
       "type": "object"
     },
     "Parameter": {
-      "description": "A class to represent a parameter with a name and value.\n\nAttributes:\n    name (str): The name of the parameter.\n    description (str): A description of the parameter.\n    sensitive (bool): Whether the parameter contains sensitive information.\n    required (bool): Whether the parameter is required.\n    default (Optional[str]): The default value of the parameter, if any. (required if sensitive is False)",
+      "description": "A class to represent a parameter with a name and value.\n\nAttributes:\n    name (str): The name of the parameter.\n    description (str): A description of the parameter.\n    sensitive (bool): Whether the parameter contains sensitive information.\n    required (bool): Whether the parameter is required.\n    default (Optional[str]): The default value of the parameter, if any. (required if sensitive is False)\n    id (str): Unique identifier for the parameter.",
       "properties": {
         "name": {
           "title": "Name",
@@ -149,6 +149,10 @@
           ],
           "default": null,
           "title": "Default"
+        },
+        "id": {
+          "title": "Id",
+          "type": "string"
         }
       },
       "required": [
@@ -159,13 +163,20 @@
       "type": "object"
     },
     "Policy": {
-      "description": "A class to represent a policy configuration.\n\nAttributes:\n    name_prefix (str): The name of the policy, will be appended with a unique ID.\n    type (str): The type of the policy (e.g., \"terraform\", \"kubernetes\").\n    body (str): The body of the policy, typically a configuration or script.\n    labels (Optional[dict[str, str]]): Labels associated with the policy.",
+      "description": "A class to represent a policy configuration.\n\nAttributes:\n    name_prefix (str): The name of the policy, will be appended with a unique ID.\n    type (str): The type of the policy (e.g., \"terraform\", \"kubernetes\").\n    body (str): The body of the policy, typically a configuration or script.\n    labels (Optional[List[str]]): Labels associated with the policy.",
       "properties": {
         "name_prefix": {
           "title": "Name Prefix",
           "type": "string"
         },
         "type": {
+          "enum": [
+            "PUSH",
+            "PLAN",
+            "TRIGGER",
+            "APPROVAL",
+            "NOTIFICATION"
+          ],
           "title": "Type",
           "type": "string"
         },
@@ -176,10 +187,10 @@
         "labels": {
           "anyOf": [
             {
-              "additionalProperties": {
+              "items": {
                 "type": "string"
               },
-              "type": "object"
+              "type": "array"
             },
             {
               "type": "null"
@@ -238,7 +249,7 @@
       "type": "object"
     },
     "Webhook": {
-      "description": "A class to represent a webhook configuration.\n\nAttributes:\n    name_prefix (str): The name of the webhook, will be appended with a unique ID.\n    endpoint (str): The URL endpoint for the webhook.\n    labels (Optional[dict]): Labels associated with the webhook.\n    secrets (Optional[list[Variable]]): List of secrets associated with the webhook.",
+      "description": "A class to represent a webhook configuration.\n\nAttributes:\n    name_prefix (str): The name of the webhook, will be appended with a unique ID.\n    endpoint (str): The URL endpoint for the webhook.\n    labels (Optional[List[str]]): Labels associated with the webhook.\n    secret (str): the ID of the parameter where the webhook secret is retrieved from",
       "properties": {
         "name_prefix": {
           "title": "Name Prefix",
@@ -248,25 +259,22 @@
           "title": "Endpoint",
           "type": "string"
         },
-        "labels": {
+        "secretFromParameter": {
           "anyOf": [
             {
-              "additionalProperties": {
-                "type": "string"
-              },
-              "type": "object"
+              "type": "string"
             },
             {
               "type": "null"
             }
           ],
-          "title": "Labels"
+          "title": "Secretfromparameter"
         },
-        "secrets": {
+        "labels": {
           "anyOf": [
             {
               "items": {
-                "$ref": "#/$defs/Variable"
+                "type": "string"
               },
               "type": "array"
             },
@@ -274,7 +282,7 @@
               "type": "null"
             }
           ],
-          "title": "Secrets"
+          "title": "Labels"
         }
       },
       "required": [
@@ -285,10 +293,10 @@
       "type": "object"
     }
   },
-  "description": "A class to represent the manifest of a Spacelift plugin.\n\nAttributes:\n    name_prefix (str): The name of the plugin, will be appended with a unique ID.\n    description (str): A description of the plugin.\n    author (str): The author of the plugin.\n    parameters (list[Parameter]): List of parameters for the plugin.\n    contexts (list[Context]): List of contexts for the plugin.\n    webhooks (list[Webhook]): List of webhooks for the plugin.\n    policies (list[Policy]): List of policies for the plugin.",
+  "description": "A class to represent the manifest of a Spacelift plugin.\n\nAttributes:\n    name (str): The name of the plugin, will be appended with a unique ID.\n    description (str): A description of the plugin.\n    author (str): The author of the plugin.\n    labels (list[str]): List of labels for the plugin.\n    parameters (list[Parameter]): List of parameters for the plugin.\n    contexts (list[Context]): List of contexts for the plugin.\n    webhooks (list[Webhook]): List of webhooks for the plugin.\n    policies (list[Policy]): List of policies for the plugin.",
   "properties": {
-    "name_prefix": {
-      "title": "Name Prefix",
+    "name": {
+      "title": "Name",
       "type": "string"
     },
     "version": {
@@ -303,6 +311,20 @@
       "title": "Author",
       "type": "string"
     },
+    "labels": {
+      "anyOf": [
+        {
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        },
+        {
+          "type": "null"
+        }
+      ],
+      "title": "Labels"
+    },
     "parameters": {
       "anyOf": [
         {
@@ -361,11 +383,12 @@
     }
   },
   "required": [
-    "name_prefix",
+    "name",
     "version",
     "description",
     "author"
   ],
   "title": "PluginManifest",
-  "type": "object"
+  "type": "object",
+  "$schema": "http://json-schema.org/draft-07/schema#"
 }

spaceforge/templates/binary_install.sh.j2

@@ -0,0 +1,24 @@
+#!/bin/sh
+
+set -e
+
+export PATH="/mnt/workspace/plugins/plugin_binaries:$PATH"
+if command -v {{binary.name}}; then
+    echo "{{binary.name}} is already installed."
+    return
+fi
+
+mkdir -p {{static_binary_directory}}
+
+echo "Installing {{binary.name}}..."
+mkdir -p {{static_binary_directory}}
+cd {{static_binary_directory}}
+
+if [ "$(arch)" = "x86_64" ]; then
+    curl {{amd64_url}} -o {{binary_path}} -L
+else
+    curl {{arm64_url}} -o {{binary_path}} -L
+fi
+
+chmod +x {{binary_path}}
+cd /mnt/workspace/source/$TF_VAR_spacelift_project_root

spaceforge/templates/ensure_spaceforge_and_run.sh.j2

@@ -0,0 +1,24 @@
+#!/bin/sh
+
+set -e
+
+cd {{plugin_path}}
+
+if [ ! -d "./venv" ]; then
+    python -m venv ./venv
+fi
+. venv/bin/activate
+
+if ! command -v spaceforge; then
+    pip install spaceforge
+fi
+
+if [ -f requirements.txt ] && [ ! -f .spaceforge_installed_requirements ]; then
+    pip install -r requirements.txt
+    touch .spaceforge_installed_requirements
+fi
+{% if has_binaries %}
+export PATH="/mnt/workspace/plugins/plugin_binaries:$PATH"
+{% endif %}
+cd /mnt/workspace/source/$TF_VAR_spacelift_project_root
+spaceforge runner --plugin-file {{plugin_file}} {{phase}}