primitive 0.1.12__tar.gz → 0.1.14__tar.gz

{primitive-0.1.12 → primitive-0.1.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: primitive
-Version: 0.1.12
+Version: 0.1.14
 Project-URL: Documentation, https://github.com//primitivecorp/primitive-cli#readme
 Project-URL: Issues, https://github.com//primitivecorp/primitive-cli/issues
 Project-URL: Source, https://github.com//primitivecorp/primitive-cli

{primitive-0.1.12 → primitive-0.1.14}/src/primitive/__about__.py

@@ -1,4 +1,4 @@
 # SPDX-FileCopyrightText: 2024-present Dylan Stein <dylan@steins.studio>
 #
 # SPDX-License-Identifier: MIT
-__version__ = "0.1.12"
+__version__ = "0.1.14"

{primitive-0.1.12 → primitive-0.1.14}/src/primitive/agent/actions.py

@@ -32,7 +32,7 @@ class Agent(BaseAction):
                     sleep(5)
                     continue
 
-                job_runs_data = self.primitive.projects.get_job_runs(
+                job_runs_data = self.primitive.jobs.get_job_runs(
                     status="pending", first=1, reservation_id=active_reservation_id
                 )
 
@@ -52,7 +52,7 @@ class Agent(BaseAction):
                     )
 
                     github_access_token = (
-                        self.primitive.projects.github_access_token_for_job_run(
+                        self.primitive.jobs.github_access_token_for_job_run(
                             job_run["id"]
                         )
                     )
@@ -68,7 +68,7 @@ class Agent(BaseAction):
                     if job_run["job"]["slug"] == "lint":
                         logger.debug("Executing Lint Job")
 
-                        self.primitive.projects.job_run_update(
+                        self.primitive.jobs.job_run_update(
                             job_run["id"], status="request_in_progress"
                         )
 
@@ -79,7 +79,7 @@ class Agent(BaseAction):
                             conclusion = "success"
                         else:
                             conclusion = "failure"
-                        self.primitive.projects.job_run_update(
+                        self.primitive.jobs.job_run_update(
                             job_run["id"],
                             status="request_completed",
                             conclusion=conclusion,

{primitive-0.1.12 → primitive-0.1.14}/src/primitive/cli.py

@@ -9,6 +9,10 @@ from .hardware.commands import cli as hardware_commands
 from .lint.commands import cli as lint_commands
 from .agent.commands import cli as agent_commands
 from .git.commands import cli as git_commands
+from .daemons.commands import cli as daemons_commands
+from .jobs.commands import cli as jobs_commands
+from .organizations.commands import cli as organizations_commands
+from .projects.commands import cli as projects_commands
 
 
 @click.group()
@@ -59,6 +63,10 @@ cli.add_command(hardware_commands, "hardware")
 cli.add_command(lint_commands, "lint")
 cli.add_command(agent_commands, "agent")
 cli.add_command(git_commands, "git")
+cli.add_command(daemons_commands, "daemons")
+cli.add_command(jobs_commands, "jobs")
+cli.add_command(organizations_commands, "organizations")
+cli.add_command(projects_commands, "projects")
 
 if __name__ == "__main__":
     cli(obj={})

{primitive-0.1.12 → primitive-0.1.14}/src/primitive/client.py

@@ -9,6 +9,9 @@ from .hardware.actions import Hardware
 from .lint.actions import Lint
 from .agent.actions import Agent
 from .git.actions import Git
+from .daemons.actions import Daemons
+from .jobs.actions import Jobs
+from .organizations.actions import Organizations
 
 from loguru import logger
 
@@ -54,13 +57,16 @@ class Primitive:
         )
 
         self.auth: Auth = Auth(self)
+        self.organizations: Organizations = Organizations(self)
         self.projects: Projects = Projects(self)
+        self.jobs: Jobs = Jobs(self)
         self.files: Files = Files(self)
         self.simulations: Simulations = Simulations(self)
         self.hardware: Hardware = Hardware(self)
         self.lint: Lint = Lint(self)
         self.agent: Agent = Agent(self)
         self.git: Git = Git(self)
+        self.daemons: Daemons = Daemons(self)
 
     def get_host_config(self):
         self.full_config = read_config_file()

primitive-0.1.14/src/primitive/daemons/actions.py

@@ -0,0 +1,75 @@
+import platform
+import typing
+
+if typing.TYPE_CHECKING:
+    from ..client import Primitive
+
+from .launch_agents import (
+    full_launch_agent_install,
+    full_launch_agent_uninstall,
+    start_launch_agent,
+    stop_launch_agent,
+    view_launch_agent_logs,
+)
+
+from .launch_service import (
+    full_service_install,
+    full_service_uninstall,
+    start_service,
+    stop_service,
+    view_service_logs,
+)
+
+
+class Daemons:
+    def __init__(self, primitive) -> None:
+        self.primitive: Primitive = primitive
+        self.os_family = platform.system()
+
+    def install(self):
+        result = True
+        if self.os_family == "Darwin":
+            full_launch_agent_install()
+        elif self.os_family == "Linux":
+            full_service_install()
+        elif self.os_family == "Windows":
+            print("Not Implemented")
+        return result
+
+    def uninstall(self):
+        result = True
+        if self.os_family == "Darwin":
+            full_launch_agent_uninstall()
+        elif self.os_family == "Linux":
+            full_service_uninstall()
+        elif self.os_family == "Windows":
+            print("Not Implemented")
+        return result
+
+    def stop(self) -> bool:
+        result = True
+        if self.os_family == "Darwin":
+            result = stop_launch_agent()
+        elif self.os_family == "Linux":
+            stop_service()
+        elif self.os_family == "Windows":
+            print("Not Implemented")
+        return result
+
+    def start(self) -> bool:
+        result = True
+        if self.os_family == "Darwin":
+            result = start_launch_agent()
+        elif self.os_family == "Linux":
+            start_service()
+        elif self.os_family == "Windows":
+            print("Not Implemented")
+        return result
+
+    def logs(self):
+        if self.os_family == "Darwin":
+            view_launch_agent_logs()
+        elif self.os_family == "Linux":
+            view_service_logs()
+        elif self.os_family == "Windows":
+            print("Not Implemented")

primitive-0.1.14/src/primitive/daemons/commands.py

@@ -0,0 +1,65 @@
+import click
+
+from ..utils.printer import print_result
+import typing
+
+if typing.TYPE_CHECKING:
+    from ..client import Primitive
+
+
+@click.group()
+@click.pass_context
+def cli(context):
+    """Daemon"""
+    pass
+
+
+@cli.command("install")
+@click.pass_context
+def install_daemon_command(context):
+    """Install the full primitive daemon"""
+    primitive: Primitive = context.obj.get("PRIMITIVE")
+    result = primitive.daemons.install()
+    print_result(message=result, context=context)
+
+
+@cli.command("uninstall")
+@click.pass_context
+def uninstall_daemon_command(context):
+    """Uninstall the full primitive Daemon"""
+    primitive: Primitive = context.obj.get("PRIMITIVE")
+    result = primitive.daemons.uninstall()
+    print_result(message=result, context=context)
+
+
+@cli.command("stop")
+@click.pass_context
+def stop_daemon_command(context):
+    """Stop primitive Daemon"""
+    primitive: Primitive = context.obj.get("PRIMITIVE")
+    result = primitive.daemons.stop()
+    message = "stopping primitive daemon"
+    if context.obj["JSON"]:
+        message = result
+    print_result(message=message, context=context)
+
+
+@cli.command("start")
+@click.pass_context
+def start_daemon_command(context):
+    """Start primitive Daemon"""
+    primitive: Primitive = context.obj.get("PRIMITIVE")
+    result = primitive.daemons.start()
+    message = "starting primitive daemon"
+    if context.obj["JSON"]:
+        message = result
+    print_result(message=message, context=context)
+
+
+@cli.command("logs")
+@click.pass_context
+def log_daemon_command(context):
+    """Logs from primitive Daemon"""
+    primitive: Primitive = context.obj.get("PRIMITIVE")
+    result = primitive.daemons.logs()
+    print_result(message=result, context=context)

primitive-0.1.14/src/primitive/daemons/launch_agents.py

@@ -0,0 +1,144 @@
+import os
+from pathlib import Path
+import subprocess
+
+HOME_DIRECTORY = Path.home()
+CURRENT_USER = str(HOME_DIRECTORY.expanduser()).lstrip("/Users/")
+
+PRIMITIVE_BINARY_PATH = Path(HOME_DIRECTORY / ".pyenv" / "shims" / "primitive")
+PRIMITIVE_LAUNCH_AGENT_FILEPATH = Path(
+    HOME_DIRECTORY / "Library" / "LaunchAgents" / "tech.primitive.agent.plist"
+)
+PRIMITIVE_LAUNCH_AGENT_LOGS = Path(
+    HOME_DIRECTORY / "Library" / "Logs" / "tech.primitive.agent.log"
+)
+PRIMITIVE_LAUNCH_AGENT_LABEL = "tech.primitive.agent"
+PRIMITIVE_LAUNCH_AGENT_WORKING_DIR = Path(
+    HOME_DIRECTORY / "Logs" / "tech.primitive.agent.log"
+)
+
+
+def stop_launch_agent():
+    try:
+        stop_existing_process = f"launchctl stop {PRIMITIVE_LAUNCH_AGENT_LABEL}"
+        subprocess.check_output(stop_existing_process.split(" "))
+        return True
+    except subprocess.CalledProcessError as exception:
+        print("stop_launch_agent: ", exception)
+        return False
+
+
+def start_launch_agent():
+    try:
+        start_new_agent = f"launchctl start {PRIMITIVE_LAUNCH_AGENT_LABEL}"
+        subprocess.check_output(start_new_agent.split(" "))
+        return True
+    except subprocess.CalledProcessError as exception:
+        print("start_launch_agent: ", exception)
+        return False
+
+
+def unload_launch_agent():
+    try:
+        remove_existing_agent = f"launchctl unload -w {PRIMITIVE_LAUNCH_AGENT_FILEPATH}"
+        subprocess.check_output(remove_existing_agent.split(" "))
+        return True
+    except subprocess.CalledProcessError as exception:
+        print("remove_launch_agent: ", exception)
+        return False
+
+
+def load_launch_agent():
+    try:
+        load_new_plist = f"launchctl load -w {PRIMITIVE_LAUNCH_AGENT_FILEPATH}"
+        subprocess.check_output(load_new_plist.split(" "))
+        return True
+    except subprocess.CalledProcessError as exception:
+        print("load_launch_agent: ", exception)
+        return False
+
+
+def create_stdout_file():
+    if not PRIMITIVE_LAUNCH_AGENT_LOGS.exists():
+        PRIMITIVE_LAUNCH_AGENT_LOGS.parent.mkdir(parents=True, exist_ok=True)
+        PRIMITIVE_LAUNCH_AGENT_LOGS.touch()
+
+
+def delete_stdout_file():
+    if PRIMITIVE_LAUNCH_AGENT_LOGS.exists():
+        PRIMITIVE_LAUNCH_AGENT_LOGS.unlink()
+
+
+def populate_fresh_launch_agent():
+    PRIMITIVE_LAUNCH_AGENT_LOGS.parent.mkdir(parents=True, exist_ok=True)
+    PRIMITIVE_LAUNCH_AGENT_LOGS.touch()
+
+    if PRIMITIVE_LAUNCH_AGENT_FILEPATH.exists():
+        PRIMITIVE_LAUNCH_AGENT_FILEPATH.unlink()
+    PRIMITIVE_LAUNCH_AGENT_FILEPATH.parent.mkdir(parents=True, exist_ok=True)
+    PRIMITIVE_LAUNCH_AGENT_FILEPATH.touch()
+
+    PRIMITIVE_LAUNCH_AGENT_FILEPATH.write_text(
+        f"""<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>KeepAlive</key>
+    <true/>
+    <key>Label</key>
+    <string>{PRIMITIVE_LAUNCH_AGENT_LABEL}</string>
+    <key>LimitLoadToSessionType</key>
+	<array>
+		<string>Aqua</string>
+		<string>Background</string>
+		<string>LoginWindow</string>
+		<string>StandardIO</string>
+	</array>
+    <key>ProgramArguments</key>
+    <array>
+        <string>{PRIMITIVE_BINARY_PATH}</string>
+        <string>agent</string>
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>StandardErrorPath</key>
+    <string>{PRIMITIVE_LAUNCH_AGENT_LOGS}</string>
+    <key>StandardOutPath</key>
+    <string>{PRIMITIVE_LAUNCH_AGENT_LOGS}</string>
+</dict>
+</plist>"""  # noqa: E501
+    )
+    PRIMITIVE_LAUNCH_AGENT_FILEPATH.chmod(0o644)
+    verify_launch_agent()
+
+
+def verify_launch_agent():
+    plutil_check = f"plutil -lint {PRIMITIVE_LAUNCH_AGENT_FILEPATH}"
+    try:
+        subprocess.check_output(plutil_check.split(" "))
+        return True
+    except subprocess.CalledProcessError as exception:
+        print("verify_launch_agent: ", exception)
+        return False
+
+
+def view_launch_agent_logs():
+    follow_logs = f"tail -f -n +1 {PRIMITIVE_LAUNCH_AGENT_LOGS}"
+    os.system(follow_logs)
+
+
+def full_launch_agent_install():
+    stop_launch_agent()
+    unload_launch_agent()
+    populate_fresh_launch_agent()
+    create_stdout_file()
+    load_launch_agent()
+    start_launch_agent()
+
+
+def full_launch_agent_uninstall():
+    stop_launch_agent()
+    unload_launch_agent()
+    if PRIMITIVE_LAUNCH_AGENT_FILEPATH.exists():
+        PRIMITIVE_LAUNCH_AGENT_FILEPATH.unlink()
+    delete_stdout_file()

primitive-0.1.14/src/primitive/daemons/launch_service.py

@@ -0,0 +1,170 @@
+import os
+import configparser
+import subprocess
+from pathlib import Path
+
+HOME_DIRECTORY = Path.home()
+
+PRIMITIVE_BINARY_PATH = Path(HOME_DIRECTORY / ".pyenv" / "shims" / "primitive")
+
+PRIMITIVE_AGENT_SERVICE = "tech.primitive.agent.service"
+PRIMITIVE_AGENT_LOGS = "tech.primitive.agent.log"
+PRIMITIVE_AGENT_SERVICE_FILEPATH = Path(
+    HOME_DIRECTORY / ".config" / "systemd" / "user" / PRIMITIVE_AGENT_SERVICE
+)
+PRIMITIVE_AGENT_LOGS_FILEPATH = Path(
+    HOME_DIRECTORY / ".cache" / "primitive" / PRIMITIVE_AGENT_LOGS
+)
+
+
+def stop_service():
+    try:
+        if is_service_active():
+            stop_existing_service = f"systemctl --user stop {PRIMITIVE_AGENT_SERVICE}"
+            subprocess.check_output(stop_existing_service.split(" "))
+        return True
+    except subprocess.CalledProcessError as exception:
+        print("stop_service: ", exception)
+        return False
+
+
+def is_service_active():
+    try:
+        is_service_active = (
+            f"systemctl --user show {PRIMITIVE_AGENT_SERVICE} -p ActiveState --value"
+        )
+        output = subprocess.check_output(is_service_active.split(" ")).decode().strip()
+        return output == "active"
+    except subprocess.CalledProcessError as exception:
+        print("is_service_active: ", exception)
+        return False
+
+
+def disable_service():
+    try:
+        if is_service_enabled():
+            disable_existing_service = (
+                f"systemctl --user disable {PRIMITIVE_AGENT_SERVICE}"
+            )
+            subprocess.check_output(disable_existing_service.split(" "))
+        return True
+    except subprocess.CalledProcessError as exception:
+        print("disable_service: ", exception)
+        return False
+
+
+def is_service_enabled():
+    try:
+        is_service_active = (
+            f"systemctl --user show {PRIMITIVE_AGENT_SERVICE} -p UnitFileState --value"  # noqa
+        )
+        output = subprocess.check_output(is_service_active.split(" ")).decode().strip()
+        return output == "enabled"
+    except subprocess.CalledProcessError as exception:
+        print("is_service_enabled: ", exception)
+        return False
+
+
+def populate_service_file():
+    PRIMITIVE_AGENT_LOGS_FILEPATH.parent.mkdir(parents=True, exist_ok=True)
+    PRIMITIVE_AGENT_LOGS_FILEPATH.touch()
+
+    if PRIMITIVE_AGENT_SERVICE_FILEPATH.exists():
+        PRIMITIVE_AGENT_SERVICE_FILEPATH.unlink()
+    PRIMITIVE_AGENT_SERVICE_FILEPATH.parent.mkdir(parents=True, exist_ok=True)
+    PRIMITIVE_AGENT_SERVICE_FILEPATH.touch()
+
+    config = configparser.ConfigParser()
+    config.optionxform = str  # type: ignore
+
+    config["Unit"] = {
+        "Description": "Primitive Agent",
+        "After": "network.target",
+    }
+
+    config["Service"] = {
+        "ExecStart": f"{PRIMITIVE_BINARY_PATH} agent",
+        "Restart": "always",
+        "StandardError": f"append:{PRIMITIVE_AGENT_LOGS_FILEPATH}",
+        "StandardOutput": f"append:{PRIMITIVE_AGENT_LOGS_FILEPATH}",
+    }
+
+    config["Install"] = {
+        "WantedBy": "default.target",
+    }
+
+    try:
+        with open(PRIMITIVE_AGENT_SERVICE_FILEPATH, "w") as service_file:
+            config.write(service_file)
+    except IOError as exception:
+        print(f"populate_service_file: {exception}")
+
+    PRIMITIVE_AGENT_SERVICE_FILEPATH.chmod(0o644)
+    verify_service_file()
+
+
+def verify_service_file():
+    systemctl_check = (
+        f"systemctl --user show {PRIMITIVE_AGENT_SERVICE} -p CanStart --value"
+    )
+    try:
+        output = subprocess.check_output(systemctl_check.split(" ")).decode().strip()
+        if output == "no":
+            raise Exception(f"{systemctl_check} yielded {output}")
+        return True
+    except subprocess.CalledProcessError as exception:
+        print("verify_service_file: ", exception)
+        return False
+
+
+def create_stdout_file():
+    if not PRIMITIVE_AGENT_LOGS_FILEPATH.exists():
+        PRIMITIVE_AGENT_LOGS_FILEPATH.parent.mkdir(parents=True, exist_ok=True)
+        PRIMITIVE_AGENT_LOGS_FILEPATH.touch()
+
+
+def delete_stdout_file():
+    if PRIMITIVE_AGENT_LOGS_FILEPATH.exists():
+        PRIMITIVE_AGENT_LOGS_FILEPATH.unlink()
+
+
+def enable_service():
+    try:
+        enable_service = f"systemctl --user enable {PRIMITIVE_AGENT_SERVICE}"
+        subprocess.check_output(enable_service.split(" "))
+        return True
+    except subprocess.CalledProcessError as exception:
+        print("enable_service: ", exception)
+        return False
+
+
+def start_service():
+    try:
+        start_new_service = f"systemctl --user start {PRIMITIVE_AGENT_SERVICE}"
+        subprocess.check_output(start_new_service.split(" "))
+        return True
+    except subprocess.CalledProcessError as exception:
+        print("start_service: ", exception)
+        return False
+
+
+def view_service_logs():
+    follow_logs = f"tail -f -n +1 {PRIMITIVE_AGENT_LOGS_FILEPATH}"
+    os.system(follow_logs)
+
+
+def full_service_install():
+    stop_service()
+    disable_service()
+    populate_service_file()
+    create_stdout_file()
+    enable_service()
+    start_service()
+
+
+def full_service_uninstall():
+    stop_service()
+    disable_service()
+    if PRIMITIVE_AGENT_SERVICE_FILEPATH.exists():
+        PRIMITIVE_AGENT_SERVICE_FILEPATH.unlink()
+    delete_stdout_file()

{primitive-0.1.12/src/primitive/projects → primitive-0.1.14/src/primitive/jobs}/actions.py

@@ -5,7 +5,88 @@ from gql import gql
 from primitive.utils.actions import BaseAction
 
 
-class Projects(BaseAction):
+class Jobs(BaseAction):
+    def get_jobs(
+        self,
+        organization_id: Optional[str] = None,
+        project_id: Optional[str] = None,
+        job_id: Optional[str] = None,
+        slug: Optional[str] = None,
+        first: Optional[int] = 1,
+        last: Optional[int] = None,
+    ):
+        query = gql(
+            """ 
+            fragment PageInfoFragment on PageInfo {
+                hasNextPage
+                hasPreviousPage
+                startCursor
+                endCursor
+            }
+
+            fragment JobFragment on Job {
+                id
+                pk
+                slug
+                name
+                createdAt
+                updatedAt
+            }
+
+            query jobs(
+                $before: String
+                $after: String
+                $first: Int
+                $last: Int
+                $filters: JobFilters
+            ) {
+                jobs(
+                    before: $before
+                    after: $after
+                    first: $first
+                    last: $last
+                    filters: $filters
+                ) {
+                    totalCount
+                    pageInfo {
+                        ...PageInfoFragment
+                    }
+                    edges {
+                        cursor
+                        node {
+                            ...JobFragment
+                        }
+                    }
+                }
+            }
+            """
+        )
+
+        filters = {}
+        if organization_id:
+            filters["organization"] = {"id": organization_id}
+        if project_id:
+            filters["project"] = {"id": project_id}
+        if job_id:
+            filters["id"] = job_id
+        if slug:
+            filters["slug"] = {"exact": slug}
+
+        variables = {
+            "first": first,
+            "last": last,
+            "filters": filters,
+            "order": {
+                "createdAt": "DESC",
+            },
+        }
+
+        result = self.primitive.session.execute(
+            query, variable_values=variables, get_execution_result=True
+        )
+        jobs = [edge["node"] for edge in result.data["jobs"]["edges"]]
+        return jobs
+
     def get_job_runs(
         self,
         organization_id: Optional[str] = None,
@@ -114,12 +195,34 @@ query jobRuns(
     def get_job_run(self, id: str):
         query = gql(
             """
+            fragment JobRunFragment on JobRun {
+                id
+                pk
+                createdAt
+                updatedAt
+                completedAt
+                startedAt
+                status
+                conclusion
+                stdout
+                job {
+                    id
+                    pk
+                    slug
+                    name
+                    createdAt
+                    updatedAt
+                }
+                gitCommit {
+                    sha
+                    branch
+                    repoFullName
+                }
+            }
+
             query jobRun($id: GlobalID!) {
                 jobRun(id: $id) {
-                    id
-                    organization {
-                        id
-                    }
+                    ...JobRunFragment
                 }
             }
             """
@@ -173,3 +276,28 @@ query ghAppTokenForJobRun($jobRunId: GlobalID!) {
         variables = {"jobRunId": job_run_id}
         result = self.primitive.session.execute(query, variable_values=variables)
         return result["ghAppTokenForJobRun"]
+
+    def get_latest_job_run_for_job(
+        self, job_slug: Optional[str] = None, job_id: Optional[str] = None
+    ):
+        if not job_slug and not job_id:
+            raise ValueError("job_slug or job_id is required")
+        jobs_results = self.get_jobs(slug=job_slug)
+        jobs = [edge["node"] for edge in jobs_results.data["jobs"]["edges"]]
+
+        job_id = jobs.id
+        job_run_results = self.get_job_runs(job_id=job_id, first=1)
+        job_run = [edge["node"] for edge in job_run_results.data["job_runs"]["edges"]][
+            0
+        ]
+        return job_run
+
+    def job_run_start(
+        self,
+        job_slug: str,
+        job_id: str,
+    ):
+        if not job_slug and not job_id:
+            raise ValueError("job_slug or job_id is required")
+
+        self.get_jobs(slug=job_slug)

primitive-0.1.14/src/primitive/jobs/commands.py

@@ -0,0 +1,41 @@
+import click
+
+from ..utils.printer import print_result
+
+import typing
+
+if typing.TYPE_CHECKING:
+    from ..client import Primitive
+
+
+@click.group()
+@click.pass_context
+def cli(context):
+    """Jobs Commands"""
+    pass
+
+
+@cli.command("list")
+@click.pass_context
+def list(
+    context,
+    organization_slug: str = None,
+    organization_id: str = None,
+):
+    """List Job"""
+    primitive: Primitive = context.obj.get("PRIMITIVE")
+    message = primitive.jobs.get_jobs()
+    print_result(message=message, context=context)
+
+
+@cli.command("details")
+@click.argument("job_slug")
+@click.pass_context
+def details(
+    context,
+    job_slug: str = None,
+):
+    """List Job"""
+    primitive: Primitive = context.obj.get("PRIMITIVE")
+    message = primitive.jobs.get_jobs(slug=job_slug)
+    print_result(message=message, context=context)

primitive-0.1.14/src/primitive/organizations/actions.py

@@ -0,0 +1,84 @@
+from typing import Optional
+from gql import gql
+
+
+from primitive.utils.actions import BaseAction
+
+
+class Organizations(BaseAction):
+    def get_organizations(
+        self,
+        organization_id: Optional[str] = None,
+        slug: Optional[str] = None,
+        first: Optional[int] = 1,
+        last: Optional[int] = None,
+    ):
+        query = gql(
+            """ 
+            fragment PageInfoFragment on PageInfo {
+                hasNextPage
+                hasPreviousPage
+                startCursor
+                endCursor
+            }
+
+            fragment OrganizationFragment on Organization {
+                id
+                pk
+                slug
+                name
+                createdAt
+                updatedAt
+            }
+
+            query organizations(
+                $before: String
+                $after: String
+                $first: Int
+                $last: Int
+                $filters: OrganizationFilters
+                $order: OrganizationOrder
+            ) {
+                organizations(
+                    before: $before
+                    after: $after
+                    first: $first
+                    last: $last
+                    filters: $filters
+                    order: $order
+                ) {
+                    totalCount
+                    pageInfo {
+                        ...PageInfoFragment
+                    }
+                    edges {
+                        cursor
+                        node {
+                            ...OrganizationFragment
+                        }
+                    }
+                }
+            }
+            """
+        )
+
+        filters = {}
+        if organization_id:
+            filters["organization"] = {"id": organization_id}
+        if slug:
+            filters["slug"] = {"exact": slug}
+
+        variables = {
+            "first": first,
+            "last": last,
+            "filters": filters,
+            "order": {
+                "createdAt": "DESC",
+            },
+        }
+
+        result = self.primitive.session.execute(
+            query, variable_values=variables, get_execution_result=True
+        )
+        organizations = [edge["node"] for edge in result.data["organizations"]["edges"]]
+        return organizations

primitive-0.1.14/src/primitive/organizations/commands.py

@@ -0,0 +1,24 @@
+import click
+
+from ..utils.printer import print_result
+
+import typing
+
+if typing.TYPE_CHECKING:
+    from ..client import Primitive
+
+
+@click.group()
+@click.pass_context
+def cli(context):
+    """Organizations Commands"""
+    pass
+
+
+@cli.command("list")
+@click.pass_context
+def details(context):
+    """List Organizations"""
+    primitive: Primitive = context.obj.get("PRIMITIVE")
+    message = primitive.organizations.get_organizations()
+    print_result(message=message, context=context)

primitive-0.1.14/src/primitive/projects/actions.py

@@ -0,0 +1,79 @@
+from gql import gql
+
+from typing import Optional
+from primitive.utils.actions import BaseAction
+
+
+class Projects(BaseAction):
+
+    def get_projects(
+        self,
+        organization_id: Optional[str] = None,
+        slug: Optional[str] = None,
+        first: Optional[int] = 1,
+        last: Optional[int] = None,
+    ):
+        query = gql(
+            """ 
+            fragment PageInfoFragment on PageInfo {
+                hasNextPage
+                hasPreviousPage
+                startCursor
+                endCursor
+            }
+
+            fragment ProjectFragment on Project {
+                id
+                pk
+                slug
+                name
+                createdAt
+                updatedAt
+            }
+
+            query projects(
+                $before: String
+                $after: String
+                $first: Int
+                $last: Int
+                $filters: ProjectFilters
+            ) {
+                projects(
+                    before: $before
+                    after: $after
+                    first: $first
+                    last: $last
+                    filters: $filters
+                ) {
+                    totalCount
+                    pageInfo {
+                        ...PageInfoFragment
+                    }
+                    edges {
+                        cursor
+                        node {
+                            ...ProjectFragment
+                        }
+                    }
+                }
+            }
+            """
+        )
+
+        filters = {}
+        if organization_id:
+            filters["organization"] = {"id": organization_id}
+        if slug:
+            filters["slug"] = {"exact": slug}
+
+        variables = {
+            "first": first,
+            "last": last,
+            "filters": filters,
+        }
+
+        result = self.primitive.session.execute(
+            query, variable_values=variables, get_execution_result=True
+        )
+        projects = [edge["node"] for edge in result.data["projects"]["edges"]]
+        return projects

primitive-0.1.14/src/primitive/projects/commands.py

@@ -0,0 +1,24 @@
+import click
+
+from ..utils.printer import print_result
+
+import typing
+
+if typing.TYPE_CHECKING:
+    from ..client import Primitive
+
+
+@click.group()
+@click.pass_context
+def cli(context):
+    """Projects Commands"""
+    pass
+
+
+@cli.command("list")
+@click.pass_context
+def list(context):
+    """List Projects"""
+    primitive: Primitive = context.obj.get("PRIMITIVE")
+    message = primitive.projects.get_projects()
+    print_result(message=message, context=context)