gulp-cli 0.0.0__py3-none-any.whl

gulp_cli/__init__.py

@@ -0,0 +1 @@
+"""gulp-cli package."""

gulp_cli/__main__.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from gulp_cli.cli import app
+
+
+def main() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    main()

gulp_cli/cli.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+import typer
+
+from gulp_cli.commands.acl import app as acl_app
+from gulp_cli.commands.auth import app as auth_app
+from gulp_cli.commands.collab import app as collab_app
+from gulp_cli.commands.context import app as context_app
+from gulp_cli.commands.db import app as db_app
+from gulp_cli.commands.enhance_map import app as enhance_map_app
+from gulp_cli.commands.glyph import app as glyph_app
+from gulp_cli.commands.ingest import app as ingest_app
+from gulp_cli.commands.mapping import app as mapping_app
+from gulp_cli.commands.operations import app as operation_app
+from gulp_cli.commands.plugin import app as plugin_app
+from gulp_cli.commands.query import app as query_app
+from gulp_cli.commands.source import app as source_app
+from gulp_cli.commands.stats import app as stats_app
+from gulp_cli.commands.storage import app as storage_app
+from gulp_cli.commands.user_group import app as user_group_app
+from gulp_cli.commands.users import app as user_app
+from gulp_cli.config import set_runtime_as_user, set_runtime_verbose
+from gulp_cli.extensions import load_extensions
+
+app = typer.Typer(
+    no_args_is_help=True,
+    help="Modern CLI for gULP, powered by gulp-sdk",
+)
+
+
+@app.callback()
+def main(
+    as_user: str | None = typer.Option(
+        None,
+        "--as-user",
+        help="Use the saved session of a different already-logged-in user for this command only.",
+    ),
+    verbose: bool = typer.Option(
+        False,
+        "--verbose",
+        help="Print complete result JSON instead of summary (global override).",
+    ),
+) -> None:
+    set_runtime_as_user(as_user)
+    set_runtime_verbose(verbose)
+
+app.add_typer(auth_app, name="auth")
+app.add_typer(user_app, name="user")
+app.add_typer(user_group_app, name="user-group")
+app.add_typer(operation_app, name="operation")
+app.add_typer(context_app, name="context")
+app.add_typer(source_app, name="source")
+app.add_typer(ingest_app, name="ingest")
+app.add_typer(query_app, name="query")
+app.add_typer(stats_app, name="stats")
+app.add_typer(storage_app, name="storage")
+app.add_typer(collab_app, name="collab")
+app.add_typer(db_app, name="db")
+app.add_typer(acl_app, name="acl")
+app.add_typer(plugin_app, name="plugin")
+app.add_typer(mapping_app, name="mapping")
+app.add_typer(enhance_map_app, name="enhance-map")
+app.add_typer(glyph_app, name="glyph")
+
+load_extensions(
+    app,
+    command_groups={
+        "auth": auth_app,
+        "user": user_app,
+        "user-group": user_group_app,
+        "operation": operation_app,
+        "context": context_app,
+        "source": source_app,
+        "ingest": ingest_app,
+        "query": query_app,
+        "stats": stats_app,
+        "storage": storage_app,
+        "collab": collab_app,
+        "db": db_app,
+        "acl": acl_app,
+        "plugin": plugin_app,
+        "mapping": mapping_app,
+        "enhance-map": enhance_map_app,
+        "glyph": glyph_app,
+    },
+)

gulp_cli/client.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from contextlib import asynccontextmanager
+from typing import AsyncIterator
+
+from gulp_sdk.client import GulpClient
+
+from gulp_cli.config import get_required_url_token
+
+
+@asynccontextmanager
+async def get_client() -> AsyncIterator[GulpClient]:
+    url, token = get_required_url_token()
+    async with GulpClient(url, token=token) as client:
+        yield client

gulp_cli/config.py

@@ -0,0 +1,182 @@
+from __future__ import annotations
+
+import json
+from contextvars import ContextVar
+from pathlib import Path
+from typing import Any
+
+CONFIG_DIR = Path.home() / ".config" / "gulp-cli"
+CONFIG_PATH = CONFIG_DIR / "config.json"
+_AS_USER_OVERRIDE: ContextVar[str | None] = ContextVar("gulp_cli_as_user_override", default=None)
+_VERBOSE_OVERRIDE: ContextVar[bool] = ContextVar("gulp_cli_verbose_override", default=False)
+
+
+class CLIConfigError(Exception):
+    """Raised when CLI config is missing or invalid."""
+
+
+def _normalize_config(data: dict[str, Any]) -> dict[str, Any]:
+    sessions_raw = data.get("sessions")
+    sessions: dict[str, dict[str, Any]] = {}
+
+    if isinstance(sessions_raw, dict):
+        for username, session in sessions_raw.items():
+            if not isinstance(session, dict):
+                continue
+
+            name = str(username).strip()
+            url = str(session.get("url") or data.get("url") or "").strip()
+            token = str(session.get("token") or "").strip()
+            user_id = str(session.get("user_id") or name).strip()
+
+            if not name or not url or not token:
+                continue
+
+            sessions[name] = {
+                "url": url.rstrip("/"),
+                "token": token,
+                "user_id": user_id,
+                "expires_at": session.get("expires_at"),
+            }
+    else:
+        url = str(data.get("url") or "").strip()
+        token = str(data.get("token") or "").strip()
+        user_id = str(data.get("user_id") or "").strip()
+        if url and token:
+            username = user_id or "default"
+            sessions[username] = {
+                "url": url.rstrip("/"),
+                "token": token,
+                "user_id": user_id or username,
+                "expires_at": data.get("expires_at"),
+            }
+
+    active_user = str(data.get("active_user") or "").strip()
+    if active_user not in sessions:
+        active_user = next(iter(sessions), "")
+
+    return {
+        "active_user": active_user,
+        "sessions": sessions,
+    }
+
+
+def load_config() -> dict[str, Any]:
+    if not CONFIG_PATH.exists():
+        return {"active_user": "", "sessions": {}}
+    try:
+        raw = json.loads(CONFIG_PATH.read_text(encoding="utf-8"))
+    except json.JSONDecodeError as exc:
+        raise CLIConfigError(f"Invalid config JSON in {CONFIG_PATH}: {exc}") from exc
+    if not isinstance(raw, dict):
+        raise CLIConfigError(f"Invalid config JSON in {CONFIG_PATH}: root object must be a JSON object")
+    return _normalize_config(raw)
+
+
+def save_config(data: dict[str, Any]) -> None:
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    normalized = _normalize_config(data)
+    CONFIG_PATH.write_text(json.dumps(normalized, indent=2, sort_keys=True), encoding="utf-8")
+
+
+def clear_config() -> None:
+    if CONFIG_PATH.exists():
+        CONFIG_PATH.unlink()
+
+
+def set_runtime_as_user(user_name: str | None) -> None:
+    value = str(user_name or "").strip() or None
+    _AS_USER_OVERRIDE.set(value)
+
+
+def get_runtime_as_user() -> str | None:
+    return _AS_USER_OVERRIDE.get()
+
+
+def set_runtime_verbose(verbose: bool) -> None:
+    _VERBOSE_OVERRIDE.set(bool(verbose))
+
+
+def get_runtime_verbose() -> bool:
+    return _VERBOSE_OVERRIDE.get()
+
+
+def get_saved_users() -> list[str]:
+    return list(load_config().get("sessions", {}).keys())
+
+
+def save_session(
+    *,
+    url: str,
+    username: str,
+    token: str,
+    user_id: str,
+    expires_at: Any,
+    make_active: bool = True,
+) -> dict[str, Any]:
+    cfg = load_config()
+    sessions = dict(cfg.get("sessions") or {})
+    name = username.strip()
+    sessions[name] = {
+        "url": url.rstrip("/"),
+        "token": token,
+        "user_id": user_id.strip() or name,
+        "expires_at": expires_at,
+    }
+    cfg["sessions"] = sessions
+    if make_active or not cfg.get("active_user"):
+        cfg["active_user"] = name
+    save_config(cfg)
+    return cfg
+
+
+def get_selected_session(user_name: str | None = None) -> dict[str, Any]:
+    cfg = load_config()
+    sessions = cfg.get("sessions") or {}
+    selected = (user_name or get_runtime_as_user() or cfg.get("active_user") or "").strip()
+
+    if not sessions:
+        raise CLIConfigError("Not authenticated. Run: gulp-cli auth login --url <url> --username <u> --password <p>")
+
+    if not selected:
+        selected = next(iter(sessions), "")
+
+    session = sessions.get(selected)
+    if not isinstance(session, dict):
+        available = ", ".join(sorted(sessions))
+        raise CLIConfigError(
+            f"User '{selected}' is not logged in. Logged-in users: {available}"
+        )
+
+    return {"username": selected, **session}
+
+
+def delete_session(user_name: str | None = None) -> dict[str, Any] | None:
+    cfg = load_config()
+    sessions = dict(cfg.get("sessions") or {})
+    selected = (user_name or get_runtime_as_user() or cfg.get("active_user") or "").strip()
+    if not selected:
+        return None
+
+    removed = sessions.pop(selected, None)
+    if removed is None:
+        return None
+
+    if sessions:
+        if cfg.get("active_user") == selected:
+            cfg["active_user"] = next(iter(sessions))
+        cfg["sessions"] = sessions
+        save_config(cfg)
+    else:
+        clear_config()
+
+    return {"username": selected, **removed}
+
+
+def get_required_url_token() -> tuple[str, str]:
+    session = get_selected_session()
+    url = str(session.get("url") or "").strip()
+    token = str(session.get("token") or "").strip()
+    if not url or not token:
+        raise CLIConfigError("Not authenticated. Run: gulp-cli auth login --url <url> --username <u> --password <p>")
+    return url, token

gulp_cli/extension_helpers.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from typing import Any, Callable
+
+from gulp_sdk.api.request_utils import wait_for_request_stats
+from gulp_sdk.websocket import WSMessage
+
+
+async def call_custom_endpoint(
+    client: Any,
+    *,
+    method: str,
+    path: str,
+    params: dict[str, Any] | None = None,
+    json_body: Any = None,
+    ensure_websocket: bool = False,
+    wait: bool = False,
+    timeout: int = 120,
+    ws_callback: Callable[[WSMessage], None] | None = None,
+) -> dict[str, Any]:
+    """
+    Execute a direct API call for extension endpoints.
+
+    Optionally ensures websocket connection and waits for terminal request stats
+    when server responds with JSend pending status.
+    """
+    if ensure_websocket or wait:
+        await client.ensure_websocket()
+
+    response: dict[str, Any] = await client._request(
+        method,
+        path,
+        params=params,
+        json=json_body,
+    )
+
+    if (
+        wait
+        and isinstance(response, dict)
+        and response.get("status") == "pending"
+        and response.get("req_id")
+    ):
+        return await wait_for_request_stats(
+            client,
+            str(response.get("req_id")),
+            timeout,
+            ws_callback=ws_callback,
+        )
+
+    return response

gulp_cli/extensions.py

@@ -0,0 +1,140 @@
+from __future__ import annotations
+
+import importlib.util
+import inspect
+from pathlib import Path
+from typing import Any, Callable
+
+import typer
+
+from gulp_cli.client import get_client
+from gulp_cli.config import CONFIG_DIR
+from gulp_cli.output import print_warning
+
+INTERNAL_EXTENSIONS_DIR = Path(__file__).resolve().parent / "extension"
+EXTERNAL_EXTENSIONS_DIR = CONFIG_DIR / "extension"
+
+
+def _is_valid_extension_file(path: Path) -> bool:
+    return path.is_file() and path.suffix == ".py" and not path.name.startswith("_")
+
+
+def discover_extensions() -> dict[str, Path]:
+    """
+    Discover extension modules from internal and external extension folders.
+
+    External modules have priority when a filename exists in both folders.
+    """
+    discovered: dict[str, Path] = {}
+
+    if INTERNAL_EXTENSIONS_DIR.exists():
+        for path in sorted(INTERNAL_EXTENSIONS_DIR.iterdir()):
+            if _is_valid_extension_file(path):
+                discovered[path.name] = path
+
+    if EXTERNAL_EXTENSIONS_DIR.exists():
+        for path in sorted(EXTERNAL_EXTENSIONS_DIR.iterdir()):
+            if _is_valid_extension_file(path):
+                discovered[path.name] = path
+
+    return discovered
+
+
+def _load_extension_module(module_name: str, path: Path) -> Any:
+    spec = importlib.util.spec_from_file_location(module_name, path)
+    if spec is None or spec.loader is None:
+        raise RuntimeError(f"Cannot load extension module spec from {path}")
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def _call_register_extension(
+    register_fn: Callable[..., Any],
+    *,
+    app: typer.Typer,
+    command_groups: dict[str, typer.Typer],
+) -> None:
+    """
+    Call register_extension with a flexible, backward-compatible signature.
+    """
+    supplied_kwargs: dict[str, Any] = {
+        "app": app,
+        "root_app": app,
+        "command_groups": command_groups,
+        "get_client": get_client,
+    }
+
+    signature = inspect.signature(register_fn)
+    accepts_var_kwargs = any(
+        p.kind == inspect.Parameter.VAR_KEYWORD
+        for p in signature.parameters.values()
+    )
+
+    kwargs: dict[str, Any] = {}
+    for name in signature.parameters:
+        if name in supplied_kwargs:
+            kwargs[name] = supplied_kwargs[name]
+
+    if accepts_var_kwargs:
+        kwargs = dict(supplied_kwargs)
+
+    if kwargs:
+        register_fn(**kwargs)
+        return
+
+    if signature.parameters:
+        register_fn(app)
+        return
+
+    register_fn()
+
+
+def load_extensions(
+    app: typer.Typer,
+    *,
+    command_groups: dict[str, typer.Typer] | None = None,
+) -> list[str]:
+    """
+    Load and register CLI extensions.
+
+    Returns:
+        List of loaded extension filenames.
+    """
+    loaded: list[str] = []
+    groups = command_groups or {}
+
+    for filename, path in sorted(discover_extensions().items()):
+        module_name = f"gulp_cli_extension_{path.stem}"
+        try:
+            module = _load_extension_module(module_name, path)
+        except Exception as exc:
+            print_warning(f"Failed to load extension {filename}: {exc}")
+            continue
+
+        register_fn = getattr(module, "register_extension", None)
+        if register_fn is None:
+            print_warning(
+                f"Skipping extension {filename}: missing register_extension function"
+            )
+            continue
+
+        if not callable(register_fn):
+            print_warning(
+                f"Skipping extension {filename}: register_extension is not callable"
+            )
+            continue
+
+        try:
+            _call_register_extension(
+                register_fn,
+                app=app,
+                command_groups=groups,
+            )
+        except Exception as exc:
+            print_warning(f"Failed to register extension {filename}: {exc}")
+            continue
+
+        loaded.append(filename)
+
+    return loaded

gulp_cli/output.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from typing import Any, Callable
+
+from rich.console import Console
+from rich.json import JSON
+from rich.table import Table
+
+from gulp_cli.config import get_runtime_verbose
+
+console = Console()
+
+
+def print_json(data: Any) -> None:
+    console.print(JSON.from_data(data))
+
+
+def print_error(message: str) -> None:
+    console.print(f"[red]Error: {message}[/red]")
+
+
+def print_warning(message: str) -> None:
+    console.print(f"[yellow]Warning: {message}[/yellow]")
+
+
+def print_kv_table(rows: list[tuple[str, Any]], title: str | None = None) -> None:
+    table = Table(title=title)
+    table.add_column("Key", style="cyan")
+    table.add_column("Value", style="white")
+    for key, value in rows:
+        table.add_row(str(key), str(value))
+    console.print(table)
+
+
+def print_records(records: list[dict[str, Any]], title: str | None = None) -> None:
+    if not records:
+        console.print("[yellow]No results[/yellow]")
+        return
+
+    keys: list[str] = []
+    for record in records:
+        for key in record.keys():
+            if key not in keys:
+                keys.append(key)
+
+    table = Table(title=title)
+    for key in keys:
+        table.add_column(str(key), overflow="fold")
+
+    for record in records:
+        table.add_row(*[str(record.get(key, "")) for key in keys])
+
+    console.print(table)
+
+
+def print_result(
+    data: Any,
+    verbose: bool | None = None,
+    formatter: Callable[[Any], None] | None = None,
+) -> None:
+    """
+    Print result data with conditional verbose mode.
+    
+    Args:
+        data: The result data to print
+        verbose: If True, always print full JSON output; if None, use global runtime verbose
+        formatter: Callable that formats/prints the summary (called only if verbose=False)
+    """
+    if verbose is None:
+        verbose = get_runtime_verbose()
+
+    if verbose:
+        print_json(data)
+    elif formatter:
+        formatter(data)
+    else:
+        # Default: print full JSON if no formatter provided
+        print_json(data)

gulp_cli/utils.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+
+import typer
+
+
+def parse_json_option(raw: str | None, *, field_name: str) -> dict[str, Any] | None:
+    if raw is None:
+        return None
+    text = raw.strip()
+    if not text:
+        return None
+    try:
+        data = json.loads(text)
+    except json.JSONDecodeError as exc:
+        raise typer.BadParameter(f"Invalid JSON for --{field_name}: {exc}") from exc
+    if not isinstance(data, dict):
+        raise typer.BadParameter(f"--{field_name} must be a JSON object")
+    return data
+
+
+def parse_json_list_option(raw: str | None, *, field_name: str) -> list[dict[str, Any]] | None:
+    if raw is None:
+        return None
+    text = raw.strip()
+    if not text:
+        return None
+    try:
+        data = json.loads(text)
+    except json.JSONDecodeError as exc:
+        raise typer.BadParameter(f"Invalid JSON for --{field_name}: {exc}") from exc
+    if isinstance(data, dict):
+        return [data]
+    if isinstance(data, list) and all(isinstance(item, dict) for item in data):
+        return data
+    raise typer.BadParameter(f"--{field_name} must be a JSON object or a list of JSON objects")
+
+
+def comma_split(raw: str | None) -> list[str]:
+    if not raw:
+        return []
+    return [item.strip() for item in raw.split(",") if item.strip()]

gulp_cli-0.0.0.dist-info/METADATA

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: gulp-cli
+Version: 0.0.0
+Summary: Command-line client for gULP
+Author-email: Mentat <info@mentat.is>
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: typer>=0.12.5
+Requires-Dist: rich>=13.7.1
+Requires-Dist: click==8.1.7
+Requires-Dist: gulp-sdk
+
+# 🚀 gulp-cli
+
+> THIS IS STILL WIP! for the cli to work, set `"ws_ignore_missing": true` in your `gulp_cfg.json` to prevent the backend from halting operations when the CLI disconnects its websocket after sending an async request. This is a temporary workaround until (if)we implement a proper solution for maintaining the websocket lifecycle in the CLI.
+
+**A modern, powerful command-line interface for gULP** — manage forensic document ingestion, querying, enrichment, and collaboration entirely from your terminal.
+
+## ✨ What can you do?
+
+- 🔐 **Authentication** — secure login with token persistence
+- 📥 **Ingestion** — ingest files (single/batch/wildcard), zip archives, with concurrent uploads
+- 🔍 **Querying** — raw OpenSearch queries, Sigma rules, external plugins
+- 🏷️ **Enrichment** — enrich documents, tag/untag, update fields
+- 👥 **User Management** — create users, manage permissions (admin only)
+- 📋 **Operations** — create/list/manage operations and contexts
+- 🔌 **Plugins** — list/upload/download plugins and mapping files
+- 🗺️ **Enhance Maps** — map `gulp.event_code` to glyph/color per plugin
+- 🖼️ **Glyphs** — create/list/update/delete custom glyphs
+- 🧩 **Dynamic Extensions** — load custom CLI commands from internal or user extension folders
+- 📊 **Stats** — monitor ingestion and query requests
+- 🎯 **Collaboration** — manage notes, links, highlights
+
+All with **beautiful terminal output**, **automatic tab completion**, and **async-first design**.
+
+---
+
+## 🚀 Quick Start
+
+### Installation
+
+```bash
+# Temporary setup: gulp-sdk is currently installed from GitHub via gulp-cli dependencies.
+# In the future, both gulp-sdk and gulp-cli will be installable directly from PyPI.
+# for now, clone this repository and install in development mode.
+# you can use your existing gulp .venv or create a new one ...
+python3 -m venv ./.venv
+source ./.venv/bin/activate
+git clone https://github.com/mentat-is/gulp-cli
+cd gulp-cli && pip install -e .
+
+# Verify installation
+gulp-cli --help
+```
+
+### Basic Usage
+
+```bash
+# Login to your gULP instance
+gulp-cli auth login --url http://localhost:8080 --username admin --password admin
+
+# Check who you are
+gulp-cli auth whoami
+
+# List operations
+gulp-cli operation list
+
+# Ingest files with wildcard
+gulp-cli ingest file my_operation win_evtx 'samples/win_evtx/*.evtx'
+
+# Query documents
+gulp-cli query raw my_operation --q '{"query":{"match_all":{}}}'
+```
+---
+
+## 📚 Documentation
+
+- **[Getting Started Guide](./docs/getting-started.md)** — auth, first operation, first ingest
+- **[Command Reference](./docs/command-reference.md)** — all available commands and options
+- **[Extensions Guide](./docs/extensions.md)** — dynamic extension loading and custom command contract
+- **[Resource Management Commands](./docs/resource-management.md)** — context, source, plugin, mapping, enhance-map, glyph
+- **[Practical Examples](./docs/examples.md)** — real-world workflows and recipes
+- **[Troubleshooting](./docs/troubleshooting-cli.md)** — common issues and solutions
+
+---

gulp_cli-0.0.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+gulp_cli/__init__.py,sha256=9eyhAp_FfXQO5PdWKgLM-WRLqaO294EP888aszYDwRQ,24
+gulp_cli/__main__.py,sha256=cneTsFHHzojBDytw_a8L1dNnCxIFYW-JBxz8IuCYcuA,137
+gulp_cli/cli.py,sha256=9HUXprfMaalDusiLnssKJS8b4Z37sLW6X1LctsoCotg,2920
+gulp_cli/client.py,sha256=R_cXA94qOINW1Hfpepsq3ihgzjk9ibAAWl66tbIakmA,398
+gulp_cli/config.py,sha256=pMRx_Mr-Hzg3egO3FckXZw7b0Ie6Nb89j6eNhfam4dc,5632
+gulp_cli/extension_helpers.py,sha256=j7QxrSPP3JAZFuDi6ok37Ch3nwF9flSISqKkVxn4ckU,1260
+gulp_cli/extensions.py,sha256=m-C0gJ6-_RG2NI-hajLIhXP80qXSUXOPDCs9vdbr5Vs,3923
+gulp_cli/output.py,sha256=VIbDBcN9Ohnyi7PcV2DpQCPDBYqD1Ij-IeetD-Ss8ts,2033
+gulp_cli/utils.py,sha256=d0tqpRW5V5t5qTHXejIqjBQS4rSF1I7ENeB9oKsjgqg,1328
+gulp_cli-0.0.0.dist-info/METADATA,sha256=x6OBoBzQVSFbuMpnQelkCRmiyK4V2HDnTi7eEJ5wCLc,3410
+gulp_cli-0.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+gulp_cli-0.0.0.dist-info/entry_points.txt,sha256=_1KOhvP8p49Nwm9KR383JAYVfCvUia2aKdArCJ43ORY,52
+gulp_cli-0.0.0.dist-info/top_level.txt,sha256=0-7D6OZIho4wqM2BZdxk6xOAdAVwo6orXeZW-TqeMfk,9
+gulp_cli-0.0.0.dist-info/RECORD,,

gulp_cli-0.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

gulp_cli-0.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+gulp-cli = gulp_cli.__main__:main

gulp_cli-0.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+gulp_cli