litelambda-cli 0.1.0__tar.gz

litelambda_cli-0.1.0/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: litelambda-cli
+Version: 0.1.0
+Summary: Official CLI for LiteLambda — Serverless Python Cron Job Platform
+Author-email: LiteLambda <support@litelambda.in>
+License-Expression: MIT
+Project-URL: Homepage, https://litelambda.in
+Project-URL: Documentation, https://litelambda.in/docs
+Project-URL: Repository, https://github.com/litelambda/litelambda-cli
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# LiteLambda CLI (`litelambda`)
+
+Official command-line interface for [LiteLambda](https://litelambda.in) — serverless Python cron job hosting without managing servers.
+
+## Installation
+
+```bash
+pip install litelambda-cli
+```
+
+## Quick Start
+
+### 1. Login
+Generate an API token from your [LiteLambda Settings](https://litelambda.in/settings/#api-tokens), then run:
+
+```bash
+litelambda login
+```
+
+### 2. Check Account
+```bash
+litelambda whoami
+```
+
+### 3. Deploy a Python Script
+Deploy any Python file on a cron schedule:
+
+```bash
+litelambda deploy scraper.py --schedule "0 9 * * *" --name "Morning Scraper"
+```
+
+With pip dependencies:
+```bash
+litelambda deploy bot.py --schedule "*/15 * * * *" --requirements requirements.txt
+```
+
+### 4. List All Jobs
+```bash
+litelambda list
+```
+
+### 5. Run a Job Manually
+```bash
+litelambda run "Morning Scraper"
+```
+
+### 6. View Execution Logs
+```bash
+litelambda logs "Morning Scraper"
+```
+
+---
+
+## License
+MIT

litelambda_cli-0.1.0/README.md

@@ -0,0 +1,55 @@
+# LiteLambda CLI (`litelambda`)
+
+Official command-line interface for [LiteLambda](https://litelambda.in) — serverless Python cron job hosting without managing servers.
+
+## Installation
+
+```bash
+pip install litelambda-cli
+```
+
+## Quick Start
+
+### 1. Login
+Generate an API token from your [LiteLambda Settings](https://litelambda.in/settings/#api-tokens), then run:
+
+```bash
+litelambda login
+```
+
+### 2. Check Account
+```bash
+litelambda whoami
+```
+
+### 3. Deploy a Python Script
+Deploy any Python file on a cron schedule:
+
+```bash
+litelambda deploy scraper.py --schedule "0 9 * * *" --name "Morning Scraper"
+```
+
+With pip dependencies:
+```bash
+litelambda deploy bot.py --schedule "*/15 * * * *" --requirements requirements.txt
+```
+
+### 4. List All Jobs
+```bash
+litelambda list
+```
+
+### 5. Run a Job Manually
+```bash
+litelambda run "Morning Scraper"
+```
+
+### 6. View Execution Logs
+```bash
+litelambda logs "Morning Scraper"
+```
+
+---
+
+## License
+MIT

litelambda_cli-0.1.0/litelambda/__init__.py

@@ -0,0 +1,6 @@
+"""
+LiteLambda CLI
+Official CLI client for LiteLambda (https://litelambda.in)
+"""
+
+__version__ = "0.1.0"

litelambda_cli-0.1.0/litelambda/client.py

@@ -0,0 +1,82 @@
+"""
+cli/litelambda/client.py
+Zero-dependency HTTP client for LiteLambda REST API.
+"""
+import json
+import urllib.request
+import urllib.error
+import urllib.parse
+from typing import Dict, Any, Optional
+from litelambda.config import get_api_url, get_api_token
+
+
+class APIError(Exception):
+    def __init__(self, message: str, status_code: Optional[int] = None, error_code: Optional[str] = None):
+        super().__init__(message)
+        self.status_code = status_code
+        self.error_code = error_code
+
+
+class LiteLambdaClient:
+    def __init__(self, token: Optional[str] = None, base_url: Optional[str] = None):
+        self.token = token or get_api_token()
+        self.base_url = (base_url or get_api_url()).rstrip("/")
+
+    def _request(self, method: str, endpoint: str, data: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        url = f"{self.base_url}/{endpoint.lstrip('/')}"
+        headers = {
+            "User-Agent": "litelambda-cli/0.1.0",
+            "Accept": "application/json",
+        }
+
+        if self.token:
+            headers["Authorization"] = f"Bearer {self.token}"
+
+        body_bytes = None
+        if data is not None:
+            headers["Content-Type"] = "application/json"
+            body_bytes = json.dumps(data).encode("utf-8")
+
+        req = urllib.request.Request(url, data=body_bytes, headers=headers, method=method.upper())
+
+        try:
+            with urllib.request.urlopen(req, timeout=30) as response:
+                resp_data = response.read().decode("utf-8")
+                if resp_data:
+                    return json.loads(resp_data)
+                return {}
+        except urllib.error.HTTPError as e:
+            raw_err = e.read().decode("utf-8")
+            err_msg = f"HTTP {e.code}: {e.reason}"
+            err_code = None
+            try:
+                parsed = json.loads(raw_err)
+                if isinstance(parsed, dict):
+                    err_msg = parsed.get("message") or parsed.get("error") or err_msg
+                    err_code = parsed.get("error_code")
+            except Exception:
+                if raw_err:
+                    err_msg = f"{err_msg} - {raw_err[:200]}"
+            raise APIError(err_msg, status_code=e.code, error_code=err_code)
+        except urllib.error.URLError as e:
+            raise APIError(f"Network error connecting to {self.base_url}: {e.reason}")
+        except Exception as e:
+            raise APIError(f"Unexpected error: {str(e)}")
+
+    def verify_auth(self) -> Dict[str, Any]:
+        return self._request("GET", "/auth/verify")
+
+    def list_crons(self) -> Dict[str, Any]:
+        return self._request("GET", "/crons")
+
+    def get_cron(self, id_or_name: str) -> Dict[str, Any]:
+        return self._request("GET", f"/crons/{urllib.parse.quote(id_or_name)}")
+
+    def deploy_cron(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+        return self._request("POST", "/crons", data=payload)
+
+    def run_cron(self, id_or_name: str) -> Dict[str, Any]:
+        return self._request("POST", f"/crons/{urllib.parse.quote(id_or_name)}/run")
+
+    def get_logs(self, id_or_name: str) -> Dict[str, Any]:
+        return self._request("GET", f"/crons/{urllib.parse.quote(id_or_name)}/logs")

litelambda_cli-0.1.0/litelambda/config.py

@@ -0,0 +1,57 @@
+"""
+cli/litelambda/config.py
+Local configuration and credential management (~/.litelambda/credentials.json).
+"""
+import os
+import json
+from pathlib import Path
+
+DEFAULT_API_URL = "https://litelambda.in/api/v1"
+CONFIG_DIR = Path.home() / ".litelambda"
+CREDENTIALS_FILE = CONFIG_DIR / "credentials.json"
+
+
+def get_api_url() -> str:
+    """Returns the API base URL, checking env var LITELAMBDA_API_URL first."""
+    return os.environ.get("LITELAMBDA_API_URL", DEFAULT_API_URL).rstrip("/")
+
+
+def get_api_token() -> str | None:
+    """Returns the API token from env var or credentials file."""
+    env_token = os.environ.get("LITELAMBDA_API_TOKEN")
+    if env_token:
+        return env_token.strip()
+
+    if not CREDENTIALS_FILE.exists():
+        return None
+
+    try:
+        with open(CREDENTIALS_FILE, "r", encoding="utf-8") as f:
+            data = json.load(f)
+            return data.get("api_token")
+    except Exception:
+        return None
+
+
+def save_credentials(token: str, user_email: str | None = None) -> None:
+    """Saves API token to ~/.litelambda/credentials.json."""
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    payload = {
+        "api_token": token.strip(),
+        "user_email": user_email,
+        "api_url": get_api_url(),
+    }
+    with open(CREDENTIALS_FILE, "w", encoding="utf-8") as f:
+        json.dump(payload, f, indent=2)
+    
+    try:
+        # Secure file permissions (owner rw only)
+        os.chmod(CREDENTIALS_FILE, 0o600)
+    except Exception:
+        pass
+
+
+def clear_credentials() -> None:
+    """Removes stored credentials."""
+    if CREDENTIALS_FILE.exists():
+        CREDENTIALS_FILE.unlink()

litelambda_cli-0.1.0/litelambda/main.py

@@ -0,0 +1,307 @@
+"""
+cli/litelambda/main.py
+CLI entrypoint for LiteLambda (litelambda-cli).
+"""
+import sys
+import os
+import argparse
+from pathlib import Path
+
+# Add package parent to sys.path if running directly as script
+pkg_parent = str(Path(__file__).resolve().parent.parent)
+if pkg_parent not in sys.path:
+    sys.path.insert(0, pkg_parent)
+
+from litelambda.client import LiteLambdaClient, APIError
+from litelambda.config import (
+    get_api_token,
+    save_credentials,
+    clear_credentials,
+    get_api_url,
+)
+
+# Terminal styling helpers
+BOLD = "\033[1m"
+DIM = "\033[2m"
+GREEN = "\033[32m"
+CYAN = "\033[36m"
+YELLOW = "\033[33m"
+RED = "\033[31m"
+RESET = "\033[0m"
+
+
+def print_success(msg: str):
+    print(f"{GREEN}✔{RESET} {msg}")
+
+
+def print_error(msg: str):
+    print(f"{RED}✖ Error:{RESET} {msg}", file=sys.stderr)
+
+
+def print_warning(msg: str):
+    print(f"{YELLOW}⚠{RESET} {msg}")
+
+
+def print_header(msg: str):
+    print(f"{BOLD}{CYAN}==>{RESET} {BOLD}{msg}{RESET}")
+
+
+def cmd_login(args):
+    """Log in with an API token."""
+    token = args.token
+    if not token:
+        print(f"\n{BOLD}LiteLambda Authentication{RESET}")
+        print(f"Generate your personal API token at: {CYAN}https://litelambda.in/settings/#api-tokens{RESET}\n")
+        try:
+            token = input(f"{BOLD}Enter your API token (ll_live_...): {RESET}").strip()
+        except (KeyboardInterrupt, EOFError):
+            print("\nCancelled.")
+            sys.exit(1)
+
+    if not token:
+        print_error("Token cannot be empty.")
+        sys.exit(1)
+
+    client = LiteLambdaClient(token=token)
+    try:
+        data = client.verify_auth()
+        user = data.get("user", {})
+        email = user.get("email")
+        plan = user.get("plan", "").title()
+        save_credentials(token, user_email=email)
+        print_success(f"Logged in successfully as {BOLD}{email}{RESET} ({plan} plan).")
+        print(f"Credentials stored in {DIM}~/.litelambda/credentials.json{RESET}")
+    except APIError as e:
+        print_error(f"Authentication failed: {e}")
+        sys.exit(1)
+
+
+def cmd_whoami(args):
+    """Show current logged-in user and account stats."""
+    client = LiteLambdaClient()
+    if not client.token:
+        print_error("Not logged in. Run `litelambda login` first.")
+        sys.exit(1)
+
+    try:
+        data = client.verify_auth()
+        u = data.get("user", {})
+        t = data.get("token", {})
+        print(f"\n{BOLD}LiteLambda Account{RESET}")
+        print(f"  {DIM}Email:{RESET}         {BOLD}{u.get('email')}{RESET}")
+        print(f"  {DIM}Plan:{RESET}          {u.get('plan', '').title()}")
+        print(f"  {DIM}Credits Left:{RESET}  {GREEN}{u.get('credits')}{RESET}")
+        print(f"  {DIM}Active Crons:{RESET}  {u.get('active_crons')}")
+        if u.get('trial_days_remaining') is not None:
+            print(f"  {DIM}Trial Days:{RESET}    {YELLOW}{u.get('trial_days_remaining')} days left{RESET}")
+        print(f"  {DIM}Using Token:{RESET}   {t.get('name')} ({t.get('prefix')})")
+        print()
+    except APIError as e:
+        print_error(str(e))
+        sys.exit(1)
+
+
+def cmd_list(args):
+    """List all deployed cron jobs."""
+    client = LiteLambdaClient()
+    if not client.token:
+        print_error("Not logged in. Run `litelambda login` first.")
+        sys.exit(1)
+
+    try:
+        data = client.list_crons()
+        crons = data.get("crons", [])
+        if not crons:
+            print(f"No cron jobs found. Deploy your first job with: {CYAN}litelambda deploy <file.py>{RESET}")
+            return
+
+        print(f"\n{BOLD}Deployed Cron Jobs ({len(crons)}){RESET}")
+        # Format table
+        header = f"{'NAME':<24} {'SCHEDULE':<16} {'STATUS':<10} {'TIMEOUT':<9} {'LAST RUN':<20}"
+        print(f"{DIM}{header}{RESET}")
+        print(f"{DIM}{'-' * 80}{RESET}")
+        for c in crons:
+            status = c.get('status', '').upper()
+            status_color = GREEN if status == 'ACTIVE' else YELLOW
+            last_run = c.get('last_run_at')
+            last_run_str = last_run[:19].replace('T', ' ') if last_run else "Never"
+            dur = f" ({c['last_duration_ms']}ms)" if c.get('last_duration_ms') else ""
+            print(f"{BOLD}{c['name']:<24}{RESET} {c['schedule']:<16} {status_color}{status:<10}{RESET} {str(c['timeout']) + 's':<9} {last_run_str + dur}")
+        print()
+    except APIError as e:
+        print_error(str(e))
+        sys.exit(1)
+
+
+def cmd_deploy(args):
+    """Deploy a Python script to LiteLambda."""
+    client = LiteLambdaClient()
+    if not client.token:
+        print_error("Not logged in. Run `litelambda login` first.")
+        sys.exit(1)
+
+    filepath = Path(args.file)
+    if not filepath.exists():
+        print_error(f"File not found: {filepath}")
+        sys.exit(1)
+
+    try:
+        code = filepath.read_text(encoding="utf-8")
+    except Exception as e:
+        print_error(f"Failed to read file: {e}")
+        sys.exit(1)
+
+    name = args.name or filepath.stem
+    packages = ""
+    if args.requirements:
+        req_path = Path(args.requirements)
+        if not req_path.exists():
+            print_error(f"Requirements file not found: {req_path}")
+            sys.exit(1)
+        packages = req_path.read_text(encoding="utf-8")
+
+    env_vars = ""
+    if args.env:
+        env_path = Path(args.env)
+        if env_path.exists():
+            env_vars = env_path.read_text(encoding="utf-8")
+        else:
+            # Assume inline KEY=VALUE pairs separated by comma or newline
+            env_vars = args.env.replace(",", "\n")
+
+    payload = {
+        "name": name,
+        "code": code,
+        "schedule": args.schedule,
+        "packages": packages,
+        "env_vars": env_vars,
+        "timeout": args.timeout,
+    }
+
+    print_header(f"Deploying '{name}' to LiteLambda...")
+    try:
+        res = client.deploy_cron(payload)
+        action = res.get("action", "deployed")
+        cron = res.get("cron", {})
+        print_success(f"Job successfully {action}!")
+        print(f"  {DIM}ID:{RESET}       {cron.get('id')}")
+        print(f"  {DIM}Schedule:{RESET} {cron.get('schedule')}")
+        print(f"  {DIM}Timeout:{RESET}  {cron.get('timeout')}s")
+        print(f"  {DIM}Web URL:{RESET}  {CYAN}{cron.get('web_url')}{RESET}\n")
+    except APIError as e:
+        print_error(str(e))
+        sys.exit(1)
+
+
+def cmd_run(args):
+    """Trigger manual execution of a cron job."""
+    client = LiteLambdaClient()
+    if not client.token:
+        print_error("Not logged in. Run `litelambda login` first.")
+        sys.exit(1)
+
+    id_or_name = args.cron
+    print_header(f"Triggering run for '{id_or_name}'...")
+    try:
+        res = client.run_cron(id_or_name)
+        print_success(res.get("message", "Job triggered."))
+        print(f"Check execution logs with: {CYAN}litelambda logs \"{id_or_name}\"{RESET}")
+    except APIError as e:
+        print_error(str(e))
+        sys.exit(1)
+
+
+def cmd_logs(args):
+    """View execution logs for a cron job."""
+    client = LiteLambdaClient()
+    if not client.token:
+        print_error("Not logged in. Run `litelambda login` first.")
+        sys.exit(1)
+
+    id_or_name = args.cron
+    try:
+        data = client.get_logs(id_or_name)
+        executions = data.get("executions", [])
+        if not executions:
+            print(f"No execution history recorded for '{id_or_name}'.")
+            return
+
+        latest = executions[0]
+        status = latest.get("status", "").upper()
+        status_color = GREEN if status == "SUCCESS" else (RED if status == "ERROR" else YELLOW)
+        
+        print(f"\n{BOLD}Execution Logs for '{data.get('cron_name')}'{RESET}")
+        print(f"  {DIM}Started At:{RESET} {latest.get('started_at')}")
+        print(f"  {DIM}Duration:{RESET}   {latest.get('duration_ms')} ms")
+        print(f"  {DIM}Status:{RESET}     {status_color}{status}{RESET}\n")
+
+        print(f"{DIM}{'─' * 60}{RESET}")
+        log_lines = latest.get("log_lines") or []
+        if log_lines:
+            for l in log_lines:
+                t = l.get("t", "")[11:19]
+                msg = l.get("msg", "")
+                level = l.get("level", "info")
+                color = RED if level == "error" else RESET
+                print(f"{DIM}[{t}]{RESET} {color}{msg}{RESET}")
+        elif latest.get("error_message"):
+            print(f"{RED}{latest['error_message']}{RESET}")
+        else:
+            print(f"{DIM}(Execution finished with no console output){RESET}")
+        print(f"{DIM}{'─' * 60}{RESET}\n")
+
+    except APIError as e:
+        print_error(str(e))
+        sys.exit(1)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="litelambda",
+        description="Official CLI for LiteLambda (https://litelambda.in) — Serverless Python Cron Hosting",
+    )
+    subparsers = parser.add_subparsers(dest="command", help="Command to run")
+
+    # login
+    p_login = subparsers.add_parser("login", help="Authenticate with an API token")
+    p_login.add_argument("--token", "-t", help="API token (ll_live_...)")
+    p_login.set_defaults(func=cmd_login)
+
+    # whoami
+    p_whoami = subparsers.add_parser("whoami", help="Show current logged-in account")
+    p_whoami.set_defaults(func=cmd_whoami)
+
+    # list
+    p_list = subparsers.add_parser("list", help="List all deployed cron jobs")
+    p_list.set_defaults(func=cmd_list)
+
+    # deploy
+    p_deploy = subparsers.add_parser("deploy", help="Deploy a Python script on schedule")
+    p_deploy.add_argument("file", help="Path to Python script (.py)")
+    p_deploy.add_argument("--schedule", "-s", default="*/5 * * * *", help="Cron schedule expression (default: '*/5 * * * *')")
+    p_deploy.add_argument("--name", "-n", help="Cron job name (defaults to filename)")
+    p_deploy.add_argument("--requirements", "-r", help="Path to requirements.txt")
+    p_deploy.add_argument("--env", "-e", help="Path to .env file or comma-separated KEY=VALUE pairs")
+    p_deploy.add_argument("--timeout", type=int, default=30, help="Execution timeout in seconds (default: 30)")
+    p_deploy.set_defaults(func=cmd_deploy)
+
+    # run
+    p_run = subparsers.add_parser("run", help="Trigger a cron job execution manually")
+    p_run.add_argument("cron", help="Name or UUID of the cron job")
+    p_run.set_defaults(func=cmd_run)
+
+    # logs
+    p_logs = subparsers.add_parser("logs", help="View recent execution logs")
+    p_logs.add_argument("cron", help="Name or UUID of the cron job")
+    p_logs.set_defaults(func=cmd_logs)
+
+    args = parser.parse_args()
+    if not args.command:
+        parser.print_help()
+        sys.exit(0)
+
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()

litelambda_cli-0.1.0/litelambda_cli.egg-info/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: litelambda-cli
+Version: 0.1.0
+Summary: Official CLI for LiteLambda — Serverless Python Cron Job Platform
+Author-email: LiteLambda <support@litelambda.in>
+License-Expression: MIT
+Project-URL: Homepage, https://litelambda.in
+Project-URL: Documentation, https://litelambda.in/docs
+Project-URL: Repository, https://github.com/litelambda/litelambda-cli
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# LiteLambda CLI (`litelambda`)
+
+Official command-line interface for [LiteLambda](https://litelambda.in) — serverless Python cron job hosting without managing servers.
+
+## Installation
+
+```bash
+pip install litelambda-cli
+```
+
+## Quick Start
+
+### 1. Login
+Generate an API token from your [LiteLambda Settings](https://litelambda.in/settings/#api-tokens), then run:
+
+```bash
+litelambda login
+```
+
+### 2. Check Account
+```bash
+litelambda whoami
+```
+
+### 3. Deploy a Python Script
+Deploy any Python file on a cron schedule:
+
+```bash
+litelambda deploy scraper.py --schedule "0 9 * * *" --name "Morning Scraper"
+```
+
+With pip dependencies:
+```bash
+litelambda deploy bot.py --schedule "*/15 * * * *" --requirements requirements.txt
+```
+
+### 4. List All Jobs
+```bash
+litelambda list
+```
+
+### 5. Run a Job Manually
+```bash
+litelambda run "Morning Scraper"
+```
+
+### 6. View Execution Logs
+```bash
+litelambda logs "Morning Scraper"
+```
+
+---
+
+## License
+MIT

litelambda_cli-0.1.0/litelambda_cli.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+litelambda/__init__.py
+litelambda/client.py
+litelambda/config.py
+litelambda/main.py
+litelambda_cli.egg-info/PKG-INFO
+litelambda_cli.egg-info/SOURCES.txt
+litelambda_cli.egg-info/dependency_links.txt
+litelambda_cli.egg-info/entry_points.txt
+litelambda_cli.egg-info/top_level.txt

litelambda_cli-0.1.0/litelambda_cli.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

litelambda_cli-0.1.0/litelambda_cli.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+litelambda = litelambda.main:main

litelambda_cli-0.1.0/litelambda_cli.egg-info/top_level.txt

@@ -0,0 +1 @@
+litelambda

litelambda_cli-0.1.0/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "litelambda-cli"
+version = "0.1.0"
+authors = [
+  { name="LiteLambda", email="support@litelambda.in" },
+]
+description = "Official CLI for LiteLambda — Serverless Python Cron Job Platform"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+    "Environment :: Console",
+    "Topic :: Software Development :: Build Tools",
+]
+
+[project.urls]
+Homepage = "https://litelambda.in"
+Documentation = "https://litelambda.in/docs"
+Repository = "https://github.com/litelambda/litelambda-cli"
+
+[project.scripts]
+litelambda = "litelambda.main:main"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["litelambda*"]

litelambda_cli-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+