deploykar-mcp 0.1.0__py3-none-any.whl

deploykar_mcp/__init__.py

@@ -0,0 +1,3 @@
+"""DeployKar MCP server: deploy, monitor and debug DeployKar apps from your IDE."""
+
+__version__ = "0.1.0"

deploykar_mcp/__main__.py

@@ -0,0 +1,4 @@
+from deploykar_mcp.cli import main
+
+if __name__ == "__main__":
+    main()

deploykar_mcp/cli.py

@@ -0,0 +1,130 @@
+"""Command line entry point.
+
+    deploykar-mcp            run the MCP server over stdio (what your IDE launches)
+    deploykar-mcp login      approve access in the browser and save an API token
+    deploykar-mcp logout     revoke the saved token and delete it
+    deploykar-mcp whoami     show the account and access level of the current token
+"""
+import argparse
+import getpass
+import json
+import sys
+
+from deploykar_mcp import __version__
+from deploykar_mcp.config import (
+    RUN_COMMAND,
+    UVX_ARGS,
+    dashboard_url,
+    delete_credentials,
+    load_settings,
+    save_credentials,
+)
+from deploykar_mcp.login import LoginError, browser_login, fetch_token_info, revoke_token
+
+IDE_CONFIG = {"mcpServers": {"deploykar": {"command": "uvx", "args": UVX_ARGS}}}
+
+
+def _err(message: str) -> None:
+    print(message, file=sys.stderr)
+
+
+def _access(scopes: list[str] | None) -> str:
+    return "Deploy" if "deploy" in (scopes or []) else "Read-only"
+
+
+def cmd_serve(_args) -> int:
+    import logging
+
+    from deploykar_mcp.server import create_server
+
+    # stdout carries the MCP protocol: never print to it here. Logs go to stderr.
+    logging.getLogger("httpx").setLevel(logging.WARNING)
+    create_server().run("stdio")
+    return 0
+
+
+def cmd_login(args) -> int:
+    settings = load_settings()
+    api_url = (args.api_url or settings.api_url).rstrip("/")
+    auth_url = (args.auth_url or settings.auth_url).rstrip("/")
+    print(f"First, make sure you're signed in to DeployKar in your browser: {dashboard_url()}/login\n")
+    try:
+        if args.token or args.no_browser:
+            if args.no_browser and not args.token:
+                print(f"Create a token at:\n  {auth_url}/api-tokens/authorize\n")
+            token = (args.token or getpass.getpass("Paste your DeployKar API token: ")).strip()
+            if not token.startswith("dk_live_"):
+                _err("That doesn't look like a DeployKar API token (it should start with dk_live_).")
+                return 1
+            info = fetch_token_info(api_url, token)
+            email, scopes = info["user"]["email"], (info.get("token") or {}).get("scopes")
+        else:
+            result = browser_login(auth_url)
+            token, email, scopes = result["token"], result["user"]["email"], result.get("scopes")
+    except LoginError as exc:
+        _err(f"Login failed: {exc}")
+        return 1
+    except KeyboardInterrupt:
+        _err("\nLogin cancelled.")
+        return 130
+
+    path = save_credentials(token, email, api_url, auth_url)
+    print(f"✓ Signed in to DeployKar as {email} ({_access(scopes)} access)")
+    print(f"  Token saved to {path}")
+    if settings.token_source == "env":
+        print("  Note: DEPLOYKAR_API_TOKEN is set in your environment and takes precedence over the saved token.")
+    print("\nAdd DeployKar to your IDE's MCP settings:\n")
+    print(json.dumps(IDE_CONFIG, indent=2))
+    print("\nThen restart the MCP server in your IDE and ask: \"deploy my app to DeployKar\".")
+    return 0
+
+
+def cmd_logout(_args) -> int:
+    settings = load_settings()
+    if settings.token_source != "file":
+        if settings.token_source == "env":
+            _err("The token comes from DEPLOYKAR_API_TOKEN; remove it from your environment/IDE config instead.")
+        else:
+            print("Not signed in.")
+        return 0
+    revoked = revoke_token(settings.auth_url, settings.token)
+    delete_credentials()
+    print("✓ Signed out. " + ("The token was revoked." if revoked else
+                             "Could not revoke the token on the server; revoke it from the API tokens page if needed."))
+    return 0
+
+
+def cmd_whoami(_args) -> int:
+    settings = load_settings()
+    if not settings.token:
+        _err(f"Not signed in. Run `{RUN_COMMAND} login`.")
+        return 1
+    try:
+        info = fetch_token_info(settings.api_url, settings.token)
+    except LoginError as exc:
+        _err(f"Token check failed: {exc}")
+        return 1
+    token = info.get("token") or {}
+    print(f"Account:  {info['user']['email']}")
+    print(f"Token:    {token.get('name')} ({token.get('prefix')}…), {_access(token.get('scopes'))} access")
+    print(f"Expires:  {token.get('expires_at') or 'never'}")
+    print(f"Source:   {'DEPLOYKAR_API_TOKEN' if settings.token_source == 'env' else 'saved credentials'}")
+    return 0
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(prog="deploykar-mcp", description="DeployKar MCP server and login helper.")
+    parser.add_argument("--version", action="version", version=f"deploykar-mcp {__version__}")
+    sub = parser.add_subparsers(dest="command")
+    sub.add_parser("serve", help="run the MCP server over stdio (default)")
+    login = sub.add_parser("login", help="approve access in the browser and save an API token")
+    login.add_argument("--no-browser", action="store_true", help="paste a token created in the dashboard instead")
+    login.add_argument("--token", help="save this token (from the API tokens page) without opening a browser")
+    login.add_argument("--api-url", help=argparse.SUPPRESS)
+    login.add_argument("--auth-url", help=argparse.SUPPRESS)
+    sub.add_parser("logout", help="revoke and delete the saved token")
+    sub.add_parser("whoami", help="show the current account and token")
+    args = parser.parse_args(argv)
+
+    handlers = {None: cmd_serve, "serve": cmd_serve, "login": cmd_login, "logout": cmd_logout, "whoami": cmd_whoami}
+    sys.exit(handlers[args.command](args))

deploykar_mcp/client.py

@@ -0,0 +1,106 @@
+"""Thin async client for the DeployKar deploy-api, authenticated with a personal API token."""
+from typing import Any
+
+import anyio
+import httpx
+
+from deploykar_mcp import __version__
+from deploykar_mcp.config import RUN_COMMAND
+
+LOGIN_HINT = f"Run `{RUN_COMMAND} login` (or set DEPLOYKAR_API_TOKEN) and restart the DeployKar MCP server in your IDE."
+
+
+class DeployKarError(Exception):
+    def __init__(self, status: int, code: str | None, message: str):
+        self.status = status
+        self.code = code
+        self.message = message
+        super().__init__(message)
+
+    def user_message(self) -> str:
+        """A message the IDE's assistant can relay and act on."""
+        if self.status == 401:
+            return f"DeployKar rejected the API token ({self.message}) {LOGIN_HINT}"
+        if self.status == 403 and self.code == "ERR_403_TOK_02":
+            return (
+                "This DeployKar API token is read-only. Create a token with Deploy access "
+                f"(`{RUN_COMMAND} login`) to deploy or change settings."
+            )
+        if self.status == 403 and self.code in ("ERR_403_TOK_01", "ERR_403_TOK_03"):
+            return f"{self.message} (Not available through the MCP server.)"
+        if self.status == 429:
+            return f"DeployKar rate limit reached: {self.message}"
+        if self.status >= 500:
+            return f"DeployKar had an internal error ({self.status}). Try again shortly."
+        return self.message
+
+
+def _error_from_response(response: httpx.Response) -> DeployKarError:
+    code, message = None, None
+    try:
+        body = response.json()
+        if isinstance(body, dict):
+            code = body.get("code")
+            message = body.get("message") or (body.get("detail") if isinstance(body.get("detail"), str) else None)
+    except ValueError:
+        pass
+    return DeployKarError(response.status_code, code, message or f"HTTP {response.status_code}")
+
+
+class DeployKarClient:
+    def __init__(self, api_url: str, token: str, transport: httpx.AsyncBaseTransport | None = None, timeout: float = 30.0):
+        self.api_url = api_url.rstrip("/")
+        self._http = httpx.AsyncClient(
+            base_url=self.api_url,
+            headers={"Authorization": f"Bearer {token}", "User-Agent": f"deploykar-mcp/{__version__}"},
+            timeout=timeout,
+            transport=transport,
+        )
+
+    async def aclose(self) -> None:
+        await self._http.aclose()
+
+    async def request(self, method: str, path: str, *, params: dict | None = None, json: Any = None) -> Any:
+        try:
+            response = await self._http.request(method, path, params=params, json=json)
+        except httpx.HTTPError as exc:
+            raise DeployKarError(0, None, f"Could not reach DeployKar at {self.api_url}: {exc}") from exc
+        if response.status_code >= 400:
+            raise _error_from_response(response)
+        if not response.content:
+            return None
+        return response.json()
+
+    async def get(self, path: str, **kwargs) -> Any:
+        return await self.request("GET", path, **kwargs)
+
+    async def post(self, path: str, **kwargs) -> Any:
+        return await self.request("POST", path, **kwargs)
+
+    async def read_event_stream(self, path: str, *, max_seconds: float, max_events: int = 5000) -> tuple[list[str], bool]:
+        """Collect `data:` events from a server-sent-events endpoint.
+
+        Returns (events, finished): finished is True when the server sent [DONE] (the stream
+        ended on its own) and False when we stopped after max_seconds.
+        """
+        events: list[str] = []
+        finished = False
+        with anyio.move_on_after(max_seconds):
+            try:
+                async with self._http.stream("GET", path, timeout=httpx.Timeout(30.0, read=max_seconds + 30)) as response:
+                    if response.status_code >= 400:
+                        await response.aread()
+                        raise _error_from_response(response)
+                    async for line in response.aiter_lines():
+                        if not line.startswith("data:"):
+                            continue
+                        data = line[5:].strip()
+                        if data == "[DONE]":
+                            finished = True
+                            break
+                        events.append(data)
+                        if len(events) >= max_events:
+                            break
+            except httpx.HTTPError as exc:
+                raise DeployKarError(0, None, f"Could not reach DeployKar at {self.api_url}: {exc}") from exc
+        return events, finished

deploykar_mcp/config.py

@@ -0,0 +1,93 @@
+"""Where to reach DeployKar and which API token to use.
+
+Order of precedence for the token: DEPLOYKAR_API_TOKEN, then the credentials file
+written by `deploykar-mcp login`.
+"""
+import json
+import os
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+# Current DeployKar environment. Switch all three to deploykar.com when it goes live
+# (in a new release; saved logins follow the new defaults, see save_credentials).
+DEFAULT_API_URL = "https://dev-32786578325.deploykar.com/api/v1"
+DEFAULT_AUTH_URL = "https://dev-32786578325.deploykar.com/auth/api/v1"
+DEFAULT_DASHBOARD_URL = "http://187.127.179.204:7100"
+
+# How users run this package from PyPI (shown in hints and in the IDE config that `login` prints).
+RUN_COMMAND = "uvx deploykar-mcp"
+UVX_ARGS = ["deploykar-mcp@latest"]
+
+
+@dataclass
+class Settings:
+    api_url: str
+    auth_url: str
+    token: str | None
+    token_source: str | None  # "env" | "file" | None
+    email: str | None = None
+
+
+def dashboard_url() -> str:
+    """The DeployKar website where users sign in (the API lives at DEFAULT_API_URL)."""
+    return (os.environ.get("DEPLOYKAR_DASHBOARD_URL") or DEFAULT_DASHBOARD_URL).rstrip("/")
+
+
+def config_dir() -> Path:
+    if sys.platform == "win32" and os.environ.get("APPDATA"):
+        return Path(os.environ["APPDATA"]) / "deploykar"
+    base = os.environ.get("XDG_CONFIG_HOME") or str(Path.home() / ".config")
+    return Path(base) / "deploykar"
+
+
+def credentials_path() -> Path:
+    return config_dir() / "credentials.json"
+
+
+def _read_credentials() -> dict:
+    try:
+        return json.loads(credentials_path().read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return {}
+
+
+def load_settings() -> Settings:
+    saved = _read_credentials()
+    api_url = (os.environ.get("DEPLOYKAR_API_URL") or saved.get("api_url") or DEFAULT_API_URL).rstrip("/")
+    auth_url = (os.environ.get("DEPLOYKAR_AUTH_URL") or saved.get("auth_url") or DEFAULT_AUTH_URL).rstrip("/")
+    env_token = (os.environ.get("DEPLOYKAR_API_TOKEN") or "").strip()
+    if env_token:
+        return Settings(api_url, auth_url, env_token, "env")
+    if saved.get("token"):
+        return Settings(api_url, auth_url, saved["token"], "file", saved.get("email"))
+    return Settings(api_url, auth_url, None, None)
+
+
+def save_credentials(token: str, email: str | None, api_url: str, auth_url: str) -> Path:
+    path = credentials_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    data = {"token": token, "email": email}
+    # Remember the addresses only when they were customised, so that a later release can
+    # move everyone to new default addresses (e.g. deploykar.com) without a new login.
+    if api_url.rstrip("/") != DEFAULT_API_URL:
+        data["api_url"] = api_url
+    if auth_url.rstrip("/") != DEFAULT_AUTH_URL:
+        data["auth_url"] = auth_url
+    # Create with owner-only permissions before writing the secret.
+    fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+    with os.fdopen(fd, "w", encoding="utf-8") as f:
+        json.dump(data, f, indent=2)
+    try:
+        os.chmod(path, 0o600)
+    except OSError:
+        pass
+    return path
+
+
+def delete_credentials() -> bool:
+    try:
+        credentials_path().unlink()
+        return True
+    except FileNotFoundError:
+        return False

deploykar_mcp/login.py

@@ -0,0 +1,144 @@
+"""`deploykar-mcp login`: get an API token by approving access in the browser.
+
+1. Start a one-shot HTTP listener on 127.0.0.1 (random port).
+2. Open DeployKar's approval page with that port, a random state and a PKCE challenge.
+3. After the user approves, DeployKar redirects the browser to the listener with a short-lived code.
+4. Exchange the code + PKCE verifier for the token and save it (owner-only file permissions).
+"""
+import base64
+import hashlib
+import html
+import secrets
+import socket
+import threading
+import webbrowser
+from collections.abc import Callable
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from urllib.parse import parse_qs, urlencode, urlparse
+
+import httpx
+
+from deploykar_mcp import __version__
+
+LOGIN_TIMEOUT_SECONDS = 300
+
+
+class LoginError(Exception):
+    pass
+
+
+def _pkce_pair() -> tuple[str, str]:
+    verifier = secrets.token_urlsafe(64)[:96]
+    challenge = base64.urlsafe_b64encode(hashlib.sha256(verifier.encode("ascii")).digest()).rstrip(b"=").decode("ascii")
+    return verifier, challenge
+
+
+def _result_page(title: str, message: str) -> bytes:
+    return (
+        "<!doctype html><html><head><meta charset='utf-8'><title>DeployKar</title>"
+        "<meta name='viewport' content='width=device-width,initial-scale=1'>"
+        "<style>body{font:16px/1.5 system-ui,sans-serif;max-width:480px;margin:80px auto;padding:0 16px;"
+        "color:#17171c;background:#f6f6f8}@media(prefers-color-scheme:dark){body{color:#ececf1;background:#0f1015}}</style>"
+        f"</head><body><h1>{html.escape(title)}</h1><p>{html.escape(message)}</p></body></html>"
+    ).encode("utf-8")
+
+
+def _wait_for_callback(expected_state: str, on_ready: Callable[[int], None]) -> dict[str, str]:
+    result: dict[str, str] = {}
+    done = threading.Event()
+
+    class Handler(BaseHTTPRequestHandler):
+        def do_GET(self):  # noqa: N802
+            parsed = urlparse(self.path)
+            params = {k: v[0] for k, v in parse_qs(parsed.query).items()}
+            if parsed.path != "/callback" or params.get("state") != expected_state or done.is_set():
+                self.send_response(400)
+                self.send_header("Content-Type", "text/html; charset=utf-8")
+                self.end_headers()
+                self.wfile.write(_result_page("Invalid request", "This sign-in link is not valid. Run the login command again."))
+                return
+            result.update(params)
+            ok = "code" in params
+            self.send_response(200)
+            self.send_header("Content-Type", "text/html; charset=utf-8")
+            self.send_header("Cache-Control", "no-store")
+            self.end_headers()
+            if ok:
+                self.wfile.write(_result_page("Signed in to DeployKar", "You can close this tab and return to your terminal."))
+            else:
+                self.wfile.write(_result_page("Sign-in cancelled", "No token was created. You can close this tab."))
+            done.set()
+
+        def log_message(self, *args):  # keep the terminal quiet
+            pass
+
+    httpd = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
+    httpd.timeout = 1
+    port = httpd.server_address[1]
+    thread = threading.Thread(target=lambda: httpd.serve_forever(poll_interval=0.2), daemon=True)
+    thread.start()
+    try:
+        on_ready(port)
+        if not done.wait(LOGIN_TIMEOUT_SECONDS):
+            raise LoginError("Timed out waiting for approval in the browser.")
+    finally:
+        httpd.shutdown()
+        httpd.server_close()
+    return result
+
+
+def browser_login(auth_url: str, open_browser: Callable[[str], bool] | None = None,
+                  echo: Callable[[str], None] = print) -> dict:
+    """Run the browser approval flow and return the exchange response ({token, user, ...})."""
+    open_browser = open_browser or webbrowser.open
+    verifier, challenge = _pkce_pair()
+    state = secrets.token_urlsafe(24)
+    client_name = f"DeployKar MCP on {socket.gethostname()}"[:100]
+
+    def on_ready(port: int) -> None:
+        url = f"{auth_url}/api-tokens/authorize?" + urlencode({
+            "callback_port": port, "state": state, "code_challenge": challenge, "client_name": client_name,
+        })
+        echo("Opening your browser to approve access to DeployKar...")
+        echo(f"If it doesn't open, visit:\n  {url}\n")
+        try:
+            open_browser(url)
+        except Exception:
+            pass
+
+    params = _wait_for_callback(state, on_ready)
+    if params.get("error"):
+        raise LoginError("Access was not approved in the browser.")
+    response = httpx.post(
+        f"{auth_url}/api-tokens/exchange",
+        json={"code": params["code"], "code_verifier": verifier},
+        headers={"User-Agent": f"deploykar-mcp/{__version__}"},
+        timeout=30,
+    )
+    if response.status_code != 200:
+        try:
+            message = response.json().get("message")
+        except ValueError:
+            message = None
+        raise LoginError(message or f"Token exchange failed (HTTP {response.status_code}).")
+    return response.json()
+
+
+def fetch_token_info(api_url: str, token: str) -> dict:
+    response = httpx.get(f"{api_url}/token-info", headers={"Authorization": f"Bearer {token}",
+                                                            "User-Agent": f"deploykar-mcp/{__version__}"}, timeout=30)
+    if response.status_code != 200:
+        try:
+            message = response.json().get("message")
+        except ValueError:
+            message = None
+        raise LoginError(message or f"DeployKar rejected the token (HTTP {response.status_code}).")
+    return response.json()
+
+
+def revoke_token(auth_url: str, token: str) -> bool:
+    try:
+        response = httpx.post(f"{auth_url}/api-tokens/revoke-current", headers={"Authorization": f"Bearer {token}"}, timeout=30)
+        return response.status_code == 200
+    except httpx.HTTPError:
+        return False

deploykar_mcp/server.py

@@ -0,0 +1,465 @@
+"""DeployKar MCP server: translates IDE tool calls into DeployKar API requests.
+
+The IDE's own assistant does the reasoning; every tool here is a thin, bounded wrapper
+around an existing deploy-api endpoint.
+"""
+import re
+import time
+from collections.abc import Awaitable, Callable
+from datetime import datetime, timezone
+from typing import Any, Literal
+
+import anyio
+from mcp.server.mcpserver import Context, MCPServer
+from mcp.server.mcpserver.exceptions import ToolError
+from mcp.types import ToolAnnotations
+
+from deploykar_mcp import __version__
+from deploykar_mcp.client import LOGIN_HINT, DeployKarClient, DeployKarError
+from deploykar_mcp.config import load_settings
+
+INSTRUCTIONS = """\
+DeployKar builds and hosts apps straight from GitHub. It never uploads local files: whatever is
+pushed to the project's branch on GitHub is what gets built and deployed.
+
+Typical flow:
+1. If unsure whether the user is set up, call check_setup (it also returns the GitHub App install link).
+2. Find the project with list_projects(repo_url=<output of `git remote get-url origin`>).
+3. Before deploying, make sure local changes are committed and pushed (`git status`, `git push`).
+   Ask the user before committing or pushing on their behalf.
+4. Call deploy, then get_status(project_id, deployment_id, wait=true) and report the live URL.
+5. If the project has auto-deploy enabled, a push already starts a deployment: do not call deploy;
+   call get_status(project_id, commit_sha=<the pushed commit>, wait=true) instead.
+6. If a deployment fails, read get_logs(deployment_id=..., errors_only=true), explain the cause and
+   propose a fix. Ask the user before retrying more than once.
+
+Rules:
+- Never repeat environment variable values back to the user. Confirm with the user before sending
+  values taken from a local .env file.
+- Environment variable changes apply on the next deploy or restart (set_env_var(apply_now=true)
+  applies them immediately).
+- Deleting projects or deployments, removing backends, and managing databases, domains or secret
+  groups are not available here: point the user to the DeployKar dashboard.
+"""
+
+TERMINAL_STATUSES = {"ACTIVE", "FAILED", "REMOVED", "ROLLBACK"}
+DEPLOYABLE_TYPES = {"FRONTEND", "BACKEND"}
+ENV_KEY_RE = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
+ERROR_LINE_RE = re.compile(r"error|err!|failed|failure|exception|traceback|fatal|cannot find|not found", re.IGNORECASE)
+POLL_INTERVAL_SECONDS = 5.0
+
+READ_ONLY = ToolAnnotations(read_only_hint=True, open_world_hint=True)
+
+ClientProvider = Callable[[], DeployKarClient]
+
+
+# ─── Helpers ─────────────────────────────────────────────────────────
+
+
+def normalize_repo(url: str | None) -> str | None:
+    """'git@github.com:Owner/Repo.git', 'https://github.com/owner/repo' -> 'owner/repo'."""
+    if not url:
+        return None
+    value = url.strip()
+    value = re.sub(r"^(git\+)?(ssh://)?git@github\.com[:/]", "https://github.com/", value)
+    value = re.sub(r"^(https?://)?(www\.)?github\.com/", "", value)
+    value = value.split("?")[0].split("#")[0].strip("/")
+    if value.endswith(".git"):
+        value = value[:-4]
+    parts = value.split("/")
+    if len(parts) < 2 or not parts[0] or not parts[1]:
+        return None
+    return f"{parts[0]}/{parts[1]}".lower()
+
+
+def to_https_repo_url(url: str) -> str:
+    """Any GitHub remote form -> 'https://github.com/Owner/Repo' (the form deploy-api accepts)."""
+    m = re.search(r"github\.com[:/]+([^/\s]+)/([^/?#\s]+)", url.strip())
+    if not m:
+        raise ToolError("repo_url must be a GitHub repository URL, e.g. https://github.com/owner/repo")
+    owner, repo = m.group(1), m.group(2)
+    if repo.endswith(".git"):
+        repo = repo[:-4]
+    return f"https://github.com/{owner}/{repo}"
+
+
+def _project_summary(p: dict) -> dict:
+    return {
+        "id": p.get("id"),
+        "name": p.get("name"),
+        "type": (p.get("type") or "").lower(),
+        "repo_url": p.get("github_repo_url"),
+        "branch": p.get("github_branch"),
+        "latest_status": p.get("latest_deployment_status"),
+        "url": p.get("deployment_url"),
+        "auto_deploy": bool(p.get("auto_deploy_enabled")),
+        "env_changes_pending_restart": bool(p.get("secrets_stale")),
+    }
+
+
+def _deployment_summary(d: dict) -> dict:
+    return {
+        "id": d.get("id"),
+        "status": d.get("status"),
+        "url": d.get("deployment_url"),
+        "commit_sha": d.get("github_commit_sha"),
+        "created_at": d.get("created_at"),
+        "deployed_at": d.get("deployed_at"),
+    }
+
+
+def _format_log_entry(raw: str) -> tuple[str, str]:
+    """'level|epoch_ms|message' -> ('error', '12:01:03 [error] message')."""
+    parts = raw.split("|", 2)
+    if len(parts) == 3 and parts[1].isdigit():
+        level, ts, message = parts
+        if level == "complete":
+            outcome, _, detail = message.partition("|")
+            level, message = ("success" if outcome == "success" else "error"), f"Deployment {outcome}: {detail}".strip()
+        clock = datetime.fromtimestamp(int(ts) / 1000, tz=timezone.utc).strftime("%H:%M:%S")
+        return level, f"{clock} [{level}] {message}"
+    return "info", raw
+
+
+def _is_error(level: str, line: str) -> bool:
+    return level in ("error", "warn") or bool(ERROR_LINE_RE.search(line))
+
+
+def _api_error(exc: DeployKarError) -> ToolError:
+    return ToolError(exc.user_message())
+
+
+def _clamp(value: int | float, low: int | float, high: int | float):
+    return max(low, min(high, value))
+
+
+# ─── Server ──────────────────────────────────────────────────────────
+
+
+def default_client_provider() -> ClientProvider:
+    cache: dict[str, DeployKarClient] = {}
+
+    def provide() -> DeployKarClient:
+        settings = load_settings()
+        if not settings.token:
+            raise ToolError(f"Not signed in to DeployKar. {LOGIN_HINT}")
+        key = f"{settings.api_url}|{settings.token}"
+        if key not in cache:
+            cache.clear()
+            cache[key] = DeployKarClient(settings.api_url, settings.token)
+        return cache[key]
+
+    return provide
+
+
+def create_server(client_provider: ClientProvider | None = None) -> MCPServer:
+    get_client = client_provider or default_client_provider()
+    server = MCPServer("deploykar", instructions=INSTRUCTIONS, version=__version__, website_url="https://deploykar.com")
+
+    async def call(fn: Callable[[DeployKarClient], Awaitable[Any]]) -> Any:
+        try:
+            return await fn(get_client())
+        except DeployKarError as exc:
+            raise _api_error(exc) from exc
+
+    async def fetch_deployments(project_id: str) -> list[dict]:
+        return await call(lambda c: c.get(f"/projects/{project_id}/deployments", params={"fresh": "true"})) or []
+
+    async def read_build_logs(deployment_id: str, max_wait_seconds: float) -> tuple[list[tuple[str, str]], bool]:
+        events, finished = await call(lambda c: c.read_event_stream(
+            f"/deployments/{deployment_id}/logs", max_seconds=max_wait_seconds))
+        return [_format_log_entry(e) for e in events], finished
+
+    # ── Setup ──
+
+    @server.tool(annotations=READ_ONLY)
+    async def check_setup() -> dict[str, Any]:
+        """Check the DeployKar connection: signed-in account, API token access level, and whether
+        GitHub is connected (DeployKar deploys from GitHub repositories). Returns an install link
+        if GitHub still needs to be connected."""
+        info = await call(lambda c: c.get("/token-info"))
+        token = info.get("token") or {}
+        result: dict[str, Any] = {
+            "account": info.get("user", {}).get("email"),
+            "plan": info.get("user", {}).get("tier"),
+            "token": {
+                "name": token.get("name"),
+                "access": "deploy" if "deploy" in (token.get("scopes") or []) else "read-only",
+                "expires_at": token.get("expires_at"),
+            },
+        }
+        try:
+            gh = await call(lambda c: c.get("/github/app/status"))
+        except ToolError as exc:
+            gh = {"connected": None, "error": str(exc)}
+        github = {"connected": gh.get("connected"), "username": gh.get("github_username")}
+        if gh.get("connected") is False:
+            try:
+                install = await call(lambda c: c.get("/github/app/install"))
+                github["install_url"] = install.get("install_url")
+            except ToolError:
+                pass
+            github["next_step"] = "Ask the user to open install_url in a browser and install the DeployKar GitHub App on their repositories."
+        result["github"] = github
+        return result
+
+    # ── Projects ──
+
+    @server.tool(annotations=READ_ONLY)
+    async def list_projects(repo_url: str | None = None, team_id: str | None = None) -> dict[str, Any]:
+        """List the user's DeployKar projects (frontends and backends) with their latest status and live URL.
+
+        Pass repo_url (e.g. the output of `git remote get-url origin`) to find the project for the
+        current repository. Pass team_id to list a team's projects instead of personal ones."""
+        params = {"team_id": team_id} if team_id else None
+        stack = await call(lambda c: c.get("/stack", params=params))
+        projects = [_project_summary(p) for p in stack.get("projects", []) if p.get("type") in DEPLOYABLE_TYPES]
+        if repo_url:
+            wanted = normalize_repo(repo_url)
+            if not wanted:
+                raise ToolError("repo_url must be a GitHub repository URL, e.g. https://github.com/owner/repo")
+            projects = [p for p in projects if normalize_repo(p["repo_url"]) == wanted]
+            if not projects:
+                return {
+                    "projects": [],
+                    "message": f"No DeployKar project uses {wanted} yet. Call deploy with repo_url and "
+                               "project_type ('frontend' or 'backend') to create one.",
+                }
+        return {"projects": projects}
+
+    # ── Deploy ──
+
+    @server.tool(annotations=ToolAnnotations(read_only_hint=False, destructive_hint=False, idempotent_hint=False, open_world_hint=True))
+    async def deploy(
+        project_id: str | None = None,
+        repo_url: str | None = None,
+        project_type: Literal["frontend", "backend"] | None = None,
+        branch: str | None = None,
+        build_command: str | None = None,
+        output_dir: str | None = None,
+        port: int | None = None,
+        health_path: str | None = None,
+        enable_auto_deploy: bool | None = None,
+    ) -> dict[str, Any]:
+        """Deploy the latest pushed commit of a GitHub branch to DeployKar.
+
+        - Existing project: pass project_id (from list_projects).
+        - New project: pass repo_url and project_type ('frontend' for static sites/SPAs, 'backend'
+          for API servers); DeployKar creates the project.
+        DeployKar builds what is on GitHub, so push local commits first. Optional: branch,
+        build_command and output_dir (frontends), port and health_path (backends), and
+        enable_auto_deploy to redeploy automatically on every push to the branch.
+        Returns a deployment_id; then call get_status(..., wait=true)."""
+        if not project_id and not repo_url:
+            raise ToolError("Pass project_id for an existing project, or repo_url and project_type to create one.")
+        if not project_id and not project_type:
+            raise ToolError("project_type ('frontend' or 'backend') is required when creating a new project from repo_url.")
+        if port is not None and not 1 <= port <= 65535:
+            raise ToolError("port must be between 1 and 65535.")
+
+        body: dict[str, Any] = {}
+        if project_id:
+            body["project_id"] = project_id
+        if repo_url:
+            body["github_repo_url"] = to_https_repo_url(repo_url)
+        if project_type:
+            body["project_type"] = project_type.upper()
+        for key, value in (("github_branch", branch), ("build_command", build_command), ("output_dir", output_dir),
+                           ("port", port), ("health_path", health_path)):
+            if value is not None:
+                body[key] = value
+        if enable_auto_deploy is not None:
+            body["auto_deploy_enabled"] = enable_auto_deploy
+            if enable_auto_deploy and branch:
+                body["auto_deploy_branch"] = branch
+
+        result = await call(lambda c: c.post("/deploy", json=body))
+        return {
+            "deployment_id": result.get("deployment_id"),
+            "project_id": result.get("project_id"),
+            "status": result.get("status"),
+            "message": result.get("message"),
+            "next_step": "Call get_status with this project_id and deployment_id and wait=true to follow the build.",
+        }
+
+    @server.tool(annotations=READ_ONLY)
+    async def get_status(
+        project_id: str,
+        deployment_id: str | None = None,
+        commit_sha: str | None = None,
+        wait: bool = False,
+        timeout_seconds: int = 600,
+        ctx: Context = None,
+    ) -> dict[str, Any]:
+        """Get the status of a deployment (QUEUED, BUILDING, DEPLOYING, ACTIVE or FAILED) and its live URL.
+
+        Identify the deployment by deployment_id, or by commit_sha (useful after a git push when
+        auto-deploy is on); by default the project's latest deployment is used. With wait=true,
+        keeps checking until the deployment finishes or timeout_seconds pass (max 1800). If the
+        deployment failed, the result includes the error lines from the build log."""
+        timeout_seconds = int(_clamp(timeout_seconds, 10, 1800))
+        sha = (commit_sha or "").strip().lower() or None
+        if sha and not re.fullmatch(r"[0-9a-f]{7,40}", sha):
+            raise ToolError("commit_sha must be a git commit hash (7-40 hex characters).")
+
+        def pick(deployments: list[dict]) -> dict | None:
+            if deployment_id:
+                return next((d for d in deployments if d.get("id") == deployment_id), None)
+            if sha:
+                return next((d for d in deployments if (d.get("github_commit_sha") or "").lower().startswith(sha)), None)
+            return deployments[0] if deployments else None
+
+        started = time.monotonic()
+        timed_out = False
+        while True:
+            target = pick(await fetch_deployments(project_id))
+            if not wait or (target and target.get("status") in TERMINAL_STATUSES):
+                break
+            elapsed = time.monotonic() - started
+            if elapsed >= timeout_seconds:
+                timed_out = True
+                break
+            if ctx is not None:
+                label = target.get("status") if target else "waiting for the deployment to start"
+                await ctx.report_progress(elapsed, timeout_seconds, message=f"Deployment: {label}")
+            await anyio.sleep(POLL_INTERVAL_SECONDS)
+
+        if not target:
+            what = f"deployment {deployment_id}" if deployment_id else (f"commit {sha}" if sha else "any deployment")
+            hint = (" If auto-deploy is on it normally starts a few seconds after the push; call again with wait=true."
+                    if sha else "")
+            return {"found": False, "message": f"No DeployKar deployment found for {what} in this project.{hint}",
+                    "timed_out": timed_out}
+
+        status = target.get("status")
+        result: dict[str, Any] = {
+            "found": True,
+            "deployment": _deployment_summary(target),
+            "finished": status in TERMINAL_STATUSES,
+            "timed_out": timed_out,
+        }
+        if status == "ACTIVE":
+            result["live_url"] = target.get("deployment_url")
+        elif status == "FAILED":
+            entries, _ = await read_build_logs(target["id"], max_wait_seconds=8)
+            errors = [line for level, line in entries if _is_error(level, line)]
+            result["error_log"] = errors[-40:] or ["Build logs are no longer available (DeployKar keeps them for about an hour)."]
+            result["next_step"] = "Explain the error to the user and propose a fix; get_logs gives the full build log."
+        elif timed_out:
+            result["message"] = "Still in progress. Call get_status again with wait=true to keep following it."
+        return result
+
+    @server.tool(annotations=READ_ONLY)
+    async def get_logs(
+        project_id: str | None = None,
+        deployment_id: str | None = None,
+        source: Literal["build", "runtime"] = "build",
+        tail: int = 150,
+        errors_only: bool = False,
+        max_wait_seconds: int = 10,
+    ) -> dict[str, Any]:
+        """Read logs.
+
+        - source='build' (default): the build/deploy log of deployment_id (or the project's latest
+          deployment). Build logs are kept for about an hour.
+        - source='runtime': recent live output of a running backend service (project_id required;
+          backends only).
+        Returns the last `tail` lines (max 1000); errors_only keeps error/warning lines. For a build
+        that is still running, returns what has been logged within max_wait_seconds (max 60)."""
+        tail = int(_clamp(tail, 1, 1000))
+        max_wait = float(_clamp(max_wait_seconds, 1, 60))
+
+        if source == "runtime":
+            if not project_id:
+                raise ToolError("project_id is required for runtime logs.")
+            events, _ = await call(lambda c: c.read_event_stream(
+                f"/projects/{project_id}/service-logs", max_seconds=min(max_wait, 15)))
+            entries = [_format_log_entry(e) for e in events]
+            deployment = None
+        else:
+            if not deployment_id:
+                if not project_id:
+                    raise ToolError("Pass deployment_id, or project_id to read the latest deployment's build log.")
+                deployments = await fetch_deployments(project_id)
+                if not deployments:
+                    return {"lines": [], "message": "This project has no deployments yet."}
+                deployment = deployments[0]
+                deployment_id = deployment["id"]
+            else:
+                deployment = None
+            entries, finished = await read_build_logs(deployment_id, max_wait)
+            if not entries and finished:
+                return {"deployment_id": deployment_id, "lines": [],
+                        "message": "No build logs available. DeployKar keeps build logs for about an hour after a build."}
+
+        lines = [line for level, line in entries if not errors_only or _is_error(level, line)]
+        result: dict[str, Any] = {
+            "source": source,
+            "lines": lines[-tail:],
+            "total_lines": len(lines),
+            "truncated": len(lines) > tail,
+        }
+        if source == "build":
+            result["deployment_id"] = deployment_id
+            if deployment:
+                result["deployment_status"] = deployment.get("status")
+        return result
+
+    # ── Configuration ──
+
+    @server.tool(annotations=ToolAnnotations(read_only_hint=True, open_world_hint=True))
+    async def list_env_vars(project_id: str) -> dict[str, Any]:
+        """List the names of a project's environment variables (values are never shown)."""
+        rows = await call(lambda c: c.get(f"/projects/{project_id}/env-vars")) or []
+        return {"variables": [{"key": r.get("key"), "secret": bool(r.get("is_secret"))} for r in rows]}
+
+    @server.tool(annotations=ToolAnnotations(read_only_hint=False, destructive_hint=True, idempotent_hint=True, open_world_hint=True))
+    async def set_env_var(
+        project_id: str,
+        variables: dict[str, str],
+        secret: bool = True,
+        apply_now: bool = False,
+    ) -> dict[str, Any]:
+        """Set (create or overwrite) environment variables on a project, e.g. {"DATABASE_URL": "postgres://..."}.
+
+        Changes take effect on the next deploy or restart. With apply_now=true, backends are restarted
+        and frontends are rebuilt right away. Values are never returned. Confirm with the user before
+        sending values taken from a local .env file."""
+        if not variables:
+            raise ToolError("Pass at least one variable, e.g. {\"DATABASE_URL\": \"...\"}.")
+        if len(variables) > 50:
+            raise ToolError("Set at most 50 variables per call.")
+        bad = [k for k in variables if not ENV_KEY_RE.match(k)]
+        if bad:
+            raise ToolError(f"Invalid variable name(s): {', '.join(bad)}. Use letters, digits and underscores, not starting with a digit.")
+
+        payload = {"env_vars": [{"key": k, "value": str(v), "is_secret": secret} for k, v in variables.items()]}
+        await call(lambda c: c.post(f"/projects/{project_id}/env-vars", json=payload))
+        result: dict[str, Any] = {"saved": sorted(variables), "applied": False}
+
+        if not apply_now:
+            result["message"] = "Saved. They take effect on the next deploy or restart (call again with apply_now=true to apply now)."
+            return result
+        client = get_client()
+        try:
+            restart = await client.post(f"/projects/{project_id}/backend-action", json={"action": "restart"})
+            result.update(applied=True, action="restart", deployment_id=restart.get("deployment_id"))
+        except DeployKarError as exc:
+            if exc.code != "ERR_400_60":  # "only available for backend projects" -> it's a frontend: rebuild
+                raise _api_error(exc) from exc
+            redeploy = await call(lambda c: c.post("/deploy", json={"project_id": project_id}))
+            result.update(applied=True, action="redeploy", deployment_id=redeploy.get("deployment_id"))
+        result["next_step"] = "Call get_status with this project_id and deployment_id and wait=true."
+        return result
+
+    @server.tool(annotations=ToolAnnotations(read_only_hint=False, destructive_hint=False, idempotent_hint=True, open_world_hint=True))
+    async def scale(project_id: str, replicas: int) -> dict[str, Any]:
+        """Set the number of running instances (replicas, 1-10) of a backend service.
+        Applies within a few minutes, when the cluster picks up the change."""
+        if not 1 <= replicas <= 10:
+            raise ToolError("replicas must be between 1 and 10.")
+        result = await call(lambda c: c.post(f"/projects/{project_id}/backend-action",
+                                             json={"action": "scale", "replicas": replicas}))
+        return {"project_id": project_id, "replicas": replicas, "message": result.get("message")}
+
+    return server

deploykar_mcp-0.1.0.dist-info/METADATA

@@ -0,0 +1,193 @@
+Metadata-Version: 2.5
+Name: deploykar-mcp
+Version: 0.1.0
+Summary: MCP server for DeployKar: deploy, monitor and debug your apps from your IDE.
+Project-URL: Homepage, https://deploykar.com
+Author: DeployKar
+License-Expression: MIT
+License-File: LICENSE
+Keywords: deploy,deploykar,ide,mcp,model-context-protocol
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Requires-Dist: mcp<3,>=2.3
+Description-Content-Type: text/markdown
+
+# DeployKar MCP server
+
+Deploy, monitor and debug your [DeployKar](https://deploykar.com) apps from your IDE's AI chat:
+Kiro, Cursor, VS Code (Copilot), Claude Code, Windsurf, or any other MCP client.
+
+> "Deploy my app" · "Why did my build fail?" · "Set DATABASE_URL to postgres://…" · "Scale the API to 3 instances"
+
+Your IDE's assistant does the thinking. This server only translates its tool calls into DeployKar API
+requests, using a personal API token.
+
+## Setup (2 minutes)
+
+You need:
+- [uv](https://docs.astral.sh/uv/getting-started/installation/) installed (it provides the `uvx` command)
+- a DeployKar account. Sign in at **http://187.127.179.204:7100**
+- your app's code in a GitHub repository that DeployKar can access (connect GitHub once in the dashboard)
+
+**1. Sign in**
+
+First sign in to the DeployKar dashboard in your browser, then run:
+
+```bash
+uvx deploykar-mcp login
+```
+
+Your browser opens DeployKar's approval page. Choose **Deploy** (recommended) or **Read-only** access
+and click **Approve**. The token is saved on your computer, readable only by you:
+`~/.config/deploykar/credentials.json` (Windows: `%APPDATA%\deploykar\credentials.json`).
+
+**2. Add DeployKar to your IDE**
+
+For Claude Code, create a file named `.mcp.json` in your project folder (or run
+`claude mcp add --scope user deploykar -- uvx deploykar-mcp@latest` to add it for all projects):
+
+```json
+{
+  "mcpServers": {
+    "deploykar": {
+      "command": "uvx",
+      "args": ["deploykar-mcp@latest"]
+    }
+  }
+}
+```
+
+The same JSON works in other IDEs:
+
+| IDE | Where |
+|---|---|
+| Cursor | `~/.cursor/mcp.json` |
+| Kiro | `~/.kiro/settings/mcp.json` (or `.kiro/settings/mcp.json` in a workspace) |
+| Windsurf | `~/.codeium/windsurf/mcp_config.json` |
+
+VS Code (Copilot agent mode) uses `.vscode/mcp.json` with a slightly different shape:
+
+```json
+{
+  "servers": {
+    "deploykar": {
+      "type": "stdio",
+      "command": "uvx",
+      "args": ["deploykar-mcp@latest"]
+    }
+  }
+}
+```
+
+Open the folder in your IDE, approve the `deploykar` server when asked, and start chatting.
+`@latest` means you get new versions automatically when your IDE restarts the server.
+
+**Without the login command** (CI, remote machines, or if you prefer to paste a token): create a token
+on DeployKar's API tokens page (`https://dev-32786578325.deploykar.com/auth/api/v1/api-tokens/authorize`)
+and add it to the config. Don't commit a file that contains a token.
+
+```json
+{
+  "mcpServers": {
+    "deploykar": {
+      "command": "uvx",
+      "args": ["deploykar-mcp@latest"],
+      "env": { "DEPLOYKAR_API_TOKEN": "dk_live_..." }
+    }
+  }
+}
+```
+
+## What you can ask
+
+- "Deploy this repo to DeployKar as a frontend"
+- "Deploy my latest changes" (the assistant pushes first, then deploys and waits for the live URL)
+- "Turn on auto-deploy for main"
+- "Why did my last deploy fail? Fix it."
+- "Show me the API's logs from the last few minutes"
+- "Set DATABASE_URL to … and restart"
+- "Scale the API to 3 instances"
+
+## Tools
+
+| Tool | What it does |
+|---|---|
+| `check_setup` | Signed-in account, token access level, GitHub connection (with an install link if missing) |
+| `list_projects` | Your projects with status and live URL. Pass `repo_url` to find the project for the current repo |
+| `deploy` | Deploy an existing project, or create one from a GitHub repo URL (frontend or backend) |
+| `get_status` | Deployment status and live URL. `wait=true` follows the build; failures include the error lines |
+| `get_logs` | Build logs (`source="build"`) or live backend logs (`source="runtime"`), with `errors_only` |
+| `list_env_vars` | Environment variable names (never values) |
+| `set_env_var` | Create or update environment variables; `apply_now=true` restarts/redeploys |
+| `scale` | Set the number of instances (1-10) of a backend service |
+
+## How deployments work
+
+DeployKar builds from GitHub, not from your local files, exactly like deploying from the dashboard.
+Whatever is pushed to the project's branch is what gets deployed, so the assistant commits and pushes
+your changes (after asking you) before deploying. With auto-deploy enabled, every push to the branch
+deploys automatically and the assistant just follows the deployment for the commit it pushed.
+
+## Security
+
+- API tokens are stored hashed by DeployKar, shown once, expire after 30, 90 or 365 days, and can be
+  revoked at any time: `uvx deploykar-mcp logout`, or the API tokens page
+  (`https://dev-32786578325.deploykar.com/auth/api/v1/api-tokens/manage`).
+- Tokens can only reach a fixed set of endpoints. They can **never** delete projects or deployments,
+  remove backends, or manage databases, domains, secret groups or other tokens.
+- Read-only tokens can view projects, statuses and logs, but cannot deploy or read environment variables.
+- Environment variable values are never returned to the assistant.
+- Per-token rate limits apply (120 requests/minute, 30 deploy or scale actions/hour).
+
+## Commands
+
+```text
+uvx deploykar-mcp            run the MCP server (your IDE does this)
+uvx deploykar-mcp login      sign in via the browser (--no-browser to paste a token instead)
+uvx deploykar-mcp whoami     show the current account and token
+uvx deploykar-mcp logout     revoke and delete the saved token
+```
+
+Environment variables (all optional):
+
+| Variable | Default |
+|---|---|
+| `DEPLOYKAR_API_TOKEN` | the token saved by `login` |
+| `DEPLOYKAR_API_URL` | `https://dev-32786578325.deploykar.com/api/v1` |
+| `DEPLOYKAR_AUTH_URL` | `https://dev-32786578325.deploykar.com/auth/api/v1` |
+| `DEPLOYKAR_DASHBOARD_URL` | `http://187.127.179.204:7100` |
+
+## Troubleshooting
+
+- **"Not signed in" / "rejected the API token"**: run `uvx deploykar-mcp login` again, then restart
+  the MCP server in your IDE.
+- **The approval page asks you to sign in**: sign in at http://187.127.179.204:7100 in the same
+  browser, then reload the approval page.
+- **The server shows "Failed" or "Connection closed", or the IDE says `uvx` was not found**: your
+  IDE can't find `uvx`. Restart the IDE completely after installing uv. If that doesn't help, put the
+  full path to `uvx` in `"command"`:
+  - macOS/Linux: run `which uvx` and use what it prints, e.g. `/Users/you/.local/bin/uvx`
+  - Windows: run `where uvx` in PowerShell and use it with forward slashes, e.g.
+    `C:/Users/you/.local/bin/uvx.exe`. (Git Bash's `which uvx` prints `/c/Users/...`, which
+    Windows doesn't understand: write it as `C:/Users/...`.)
+- **"This API token is read-only"**: sign in again and choose Deploy access.
+- **Deployment built old code**: push your commits; DeployKar builds the latest commit on GitHub.
+- **No build logs**: DeployKar keeps build logs for about an hour after a build.
+
+## Development
+
+```bash
+uv run --group dev pytest
+```
+
+Releases are published to PyPI from GitHub (see `RELEASING.md` in the repository).
+
+## License
+
+MIT

deploykar_mcp-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+deploykar_mcp/__init__.py,sha256=p064QZCoDXZRVZtRjpVpSGRqoNlxlXrDPcpdqYM23VE,107
+deploykar_mcp/__main__.py,sha256=X_MyDO9k2oyoXZajaLaAPfjFOPvd7C89XqLi7XPtM5I,74
+deploykar_mcp/cli.py,sha256=wRv1VFA5M-ff0BNzf1Ykd2qJJkaKKSiCmq1s51iXPxU,5490
+deploykar_mcp/client.py,sha256=OmKAzXXFqvbccedFJhNVOxUs-nefMYjEwzVDkzEf9-U,4617
+deploykar_mcp/config.py,sha256=CvAogmxyiyjZX6whKM4GXcARK2Y2S--lOzoNgmhyWBk,3309
+deploykar_mcp/login.py,sha256=kBo8IRneBJKz7QaVJluOX6V9joVZKy7aXoKhAxL2jAU,5890
+deploykar_mcp/server.py,sha256=kkSw_muFQ9MFDZRGuhBHBGBEZqVlHAYVrhjcaaQMVuk,22785
+deploykar_mcp-0.1.0.dist-info/METADATA,sha256=gv8A__qcUdUk5_Twgk7M4gAv7Gg76MmHBweV7Tg6cnA,7568
+deploykar_mcp-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+deploykar_mcp-0.1.0.dist-info/entry_points.txt,sha256=Yx9soBIyc8fGGDF2svzaqwFt9ilbRnDa6Vr1NCIhITE,57
+deploykar_mcp-0.1.0.dist-info/licenses/LICENSE,sha256=iHeGY9VEmi-yCCmJ3s_B-lW16vHgJczwcetNFGFmQc8,1066
+deploykar_mcp-0.1.0.dist-info/RECORD,,

deploykar_mcp-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

deploykar_mcp-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+deploykar-mcp = deploykar_mcp.cli:main

deploykar_mcp-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DeployKar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.