@ao_zorin/zocket 1.0.0

package/docs/LOCAL_MODELS.md

@@ -0,0 +1,95 @@
+# Local Models (Ollama / Hugging Face) with zocket Workflows
+
+zocket itself is model-agnostic.  
+You can use local models in agent clients while zocket provides secrets/MCP.
+
+## 1) Ollama (local)
+
+Start Ollama and pull a model:
+```bash
+ollama serve
+ollama pull qwen2.5-coder:7b
+```
+
+Ollama OpenAI-compatible endpoint is typically:
+```text
+http://127.0.0.1:11434/v1
+```
+
+### OpenCode + Ollama
+
+`~/.config/opencode/opencode.json`:
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "provider": {
+    "ollama": {
+      "npm": "opencode-ollama",
+      "name": "Ollama",
+      "models": {
+        "qwen2.5-coder:7b": {}
+      }
+    }
+  },
+  "agent": {
+    "coder": {
+      "model": "ollama/qwen2.5-coder:7b"
+    }
+  }
+}
+```
+
+### Qwen CLI + Ollama (OpenAI-compatible)
+
+`~/.qwen/settings.json`:
+```json
+{
+  "modelProviders": {
+    "local_ollama": {
+      "name": "Local Ollama",
+      "baseURL": "http://127.0.0.1:11434/v1",
+      "apiKey": "ollama",
+      "models": ["qwen2.5-coder:7b"]
+    }
+  },
+  "model": "local_ollama/qwen2.5-coder:7b"
+}
+```
+
+## 2) Hugging Face local models
+
+Recommended path:
+- run local Text Generation Inference (TGI) server
+- expose OpenAI-compatible endpoint
+- connect client via custom provider settings
+
+Typical local endpoint:
+```text
+http://127.0.0.1:8080/v1
+```
+
+Example (Qwen CLI custom provider):
+```json
+{
+  "modelProviders": {
+    "local_hf_tgi": {
+      "name": "HF TGI Local",
+      "baseURL": "http://127.0.0.1:8080/v1",
+      "apiKey": "hf-local",
+      "models": ["Qwen/Qwen2.5-Coder-7B-Instruct"]
+    }
+  },
+  "model": "local_hf_tgi/Qwen/Qwen2.5-Coder-7B-Instruct"
+}
+```
+
+## 3) Clients that are primarily cloud-first
+
+- Codex CLI / Claude / Antigravity are primarily documented for hosted model backends.
+- Keep zocket MCP integration enabled independently from model backend choice.
+
+## 4) Security notes
+
+- Keep local model APIs on loopback only (`127.0.0.1`).
+- Do not expose local model endpoints publicly without auth and TLS.
+- Keep zocket in `metadata` mode by default for MCP clients.

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@ao_zorin/zocket",
+  "version": "1.0.0",
+  "description": "Cross-platform npm launcher for Zocket (local MCP + web vault)",
+  "license": "MIT",
+  "private": false,
+  "type": "commonjs",
+  "bin": {
+    "zocket": "bin/zocket.cjs",
+    "zocket-setup": "bin/zocket-setup.cjs"
+  },
+  "files": [
+    "bin/",
+    "docs/AI_AUTODEPLOY.md",
+    "docs/CLIENTS_MCP.md",
+    "docs/INSTALL.md",
+    "docs/LOCAL_MODELS.md",
+    "scripts/ai-autodeploy.py",
+    "scripts/install-zocket.sh",
+    "scripts/install-zocket.ps1",
+    "zocket/*.py",
+    "zocket/templates/*.html",
+    "pyproject.toml",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "test:python": "PYTHONPATH=. pytest -q",
+    "smoke:npm": "node ./bin/zocket.cjs --help"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "secrets",
+    "vault",
+    "cli",
+    "agents",
+    "codex",
+    "claude"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/aozorin/zocket.git"
+  },
+  "homepage": "https://github.com/aozorin/zocket#readme",
+  "bugs": {
+    "url": "https://github.com/aozorin/zocket/issues"
+  }
+}

package/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "zocket"
+version = "1.0.0"
+description = "Local MCP + web vault for project auth secrets"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+  "cryptography>=43.0.0",
+  "flask>=3.0.0",
+  "keyring>=25.0.0",
+  "mcp>=1.0.0",
+  "waitress>=3.0.0",
+]
+
+[project.scripts]
+zocket = "zocket.cli:main"
+
+[project.optional-dependencies]
+dev = ["pytest>=8.0.0"]
+
+[tool.setuptools.packages.find]
+include = ["zocket*"]
+
+[tool.setuptools.package-data]
+zocket = ["templates/*.html"]

package/scripts/ai-autodeploy.py

@@ -0,0 +1,127 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import os
+import platform
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+
+def run(cmd: list[str]) -> None:
+    print(f"[ai-autodeploy] $ {' '.join(cmd)}")
+    cp = subprocess.run(cmd, check=False)
+    if cp.returncode != 0:
+        raise RuntimeError(f"Command failed with code {cp.returncode}: {' '.join(cmd)}")
+
+
+def ensure_tool(name: str) -> str:
+    path = shutil.which(name)
+    if not path:
+        raise RuntimeError(f"Required tool not found: {name}")
+    return path
+
+
+def clone_or_update(repo_url: str, repo_ref: str, checkout_dir: Path) -> None:
+    git = ensure_tool("git")
+    if (checkout_dir / ".git").exists():
+        run([git, "-C", str(checkout_dir), "fetch", "--all", "--tags"])
+        run([git, "-C", str(checkout_dir), "checkout", repo_ref])
+        run([git, "-C", str(checkout_dir), "pull", "--ff-only"])
+        return
+    checkout_dir.parent.mkdir(parents=True, exist_ok=True)
+    run([git, "clone", "--depth", "1", "--branch", repo_ref, repo_url, str(checkout_dir)])
+
+
+def default_checkout_dir() -> Path:
+    if sys.platform.startswith("win"):
+        root = Path(os.environ.get("LOCALAPPDATA", str(Path.home() / "AppData" / "Local")))
+        return root / "zocket" / "bootstrap-src"
+    return Path.home() / ".local" / "share" / "zocket" / "bootstrap-src"
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description="One-file zocket bootstrap for AI agents.")
+    ap.add_argument("--repo-url", default="https://github.com/your-org/zocket.git")
+    ap.add_argument("--repo-ref", default="main")
+    ap.add_argument("--checkout-dir", default=str(default_checkout_dir()))
+    ap.add_argument("--lang", default="en", choices=["en", "ru"])
+    ap.add_argument("--web-port", default="18001")
+    ap.add_argument("--mcp-port", default="18002")
+    ap.add_argument("--mcp-mode", default="metadata", choices=["metadata", "admin"])
+    ap.add_argument("--autostart", default="user", choices=["user", "system", "none"])
+    ap.add_argument("--service-user", default="zocketd")
+    ap.add_argument("--zocket-home", default=str(Path.home() / ".zocket"))
+    args = ap.parse_args()
+
+    checkout_dir = Path(args.checkout_dir).expanduser().resolve()
+    clone_or_update(args.repo_url, args.repo_ref, checkout_dir)
+
+    system = platform.system().lower()
+    if system == "windows":
+        ps = shutil.which("pwsh") or shutil.which("powershell")
+        if not ps:
+            raise RuntimeError("PowerShell not found")
+        installer = checkout_dir / "scripts" / "install-zocket.ps1"
+        cmd = [
+            ps,
+            "-ExecutionPolicy",
+            "Bypass",
+            "-File",
+            str(installer),
+            "-Source",
+            "Local",
+            "-InstallRoot",
+            str(Path(os.environ.get("LOCALAPPDATA", str(Path.home() / "AppData" / "Local"))) / "zocket"),
+            "-ZocketHome",
+            args.zocket_home,
+            "-Lang",
+            args.lang,
+            "-WebPort",
+            args.web_port,
+            "-McpPort",
+            args.mcp_port,
+            "-McpMode",
+            args.mcp_mode,
+        ]
+        if args.autostart != "none":
+            cmd.append("-EnableAutostart")
+        run(cmd)
+    else:
+        bash = ensure_tool("bash")
+        installer = checkout_dir / "scripts" / "install-zocket.sh"
+        run(
+            [
+                bash,
+                str(installer),
+                "--source",
+                "local",
+                "--install-root",
+                str(checkout_dir.parent),
+                "--zocket-home",
+                args.zocket_home,
+                "--lang",
+                args.lang,
+                "--web-port",
+                args.web_port,
+                "--mcp-port",
+                args.mcp_port,
+                "--mcp-mode",
+                args.mcp_mode,
+                "--autostart",
+                args.autostart,
+                "--service-user",
+                args.service_user,
+            ]
+        )
+
+    print("[ai-autodeploy] Completed successfully.")
+    print("[ai-autodeploy] Web: http://127.0.0.1:18001")
+    print("[ai-autodeploy] MCP: http://127.0.0.1:18002/mcp")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/scripts/install-zocket.ps1

@@ -0,0 +1,116 @@
+Param(
+  [ValidateSet("Auto", "Local", "Git", "PyPI")]
+  [string]$Source = "Auto",
+  [string]$RepoUrl = "https://github.com/your-org/zocket.git",
+  [string]$RepoRef = "main",
+  [string]$InstallRoot = "$env:LOCALAPPDATA\zocket",
+  [string]$ZocketHome = "$env:USERPROFILE\.zocket",
+  [ValidateSet("en", "ru")]
+  [string]$Lang = "en",
+  [int]$WebPort = 18001,
+  [int]$McpPort = 18002,
+  [int]$McpStreamPort = 18003,
+  [ValidateSet("metadata", "admin")]
+  [string]$McpMode = "metadata",
+  [switch]$EnableAutostart
+)
+
+$ErrorActionPreference = "Stop"
+
+function Resolve-Python {
+  if (Get-Command py -ErrorAction SilentlyContinue) {
+    return @{Cmd = "py"; Prefix = @("-3")}
+  }
+  if (Get-Command python -ErrorAction SilentlyContinue) {
+    return @{Cmd = "python"; Prefix = @()}
+  }
+  throw "Python 3.10+ not found. Install Python and rerun."
+}
+
+function Run-Step([string]$Cmd, [string[]]$Args) {
+  & $Cmd @Args
+  if ($LASTEXITCODE -ne 0) {
+    throw "Command failed: $Cmd $($Args -join ' ')"
+  }
+}
+
+function Ensure-Dir([string]$Path) {
+  if (-not (Test-Path -LiteralPath $Path)) {
+    New-Item -ItemType Directory -Path $Path | Out-Null
+  }
+}
+
+$repoRoot = Split-Path -Parent $PSScriptRoot
+if ($Source -eq "Auto") {
+  if (Test-Path -LiteralPath (Join-Path $repoRoot "pyproject.toml")) {
+    $Source = "Local"
+  } else {
+    $Source = "Git"
+  }
+}
+
+Ensure-Dir $InstallRoot
+$srcDir = Join-Path $InstallRoot "src"
+
+$pkgSource = $null
+if ($Source -eq "Local") {
+  $pkgSource = $repoRoot
+} elseif ($Source -eq "Git") {
+  if (Test-Path -LiteralPath (Join-Path $srcDir ".git")) {
+    Run-Step "git" @("-C", $srcDir, "fetch", "--all", "--tags")
+    Run-Step "git" @("-C", $srcDir, "checkout", $RepoRef)
+    Run-Step "git" @("-C", $srcDir, "pull", "--ff-only")
+  } else {
+    if (Test-Path -LiteralPath $srcDir) {
+      Remove-Item -LiteralPath $srcDir -Recurse -Force
+    }
+    Run-Step "git" @("clone", "--depth", "1", "--branch", $RepoRef, $RepoUrl, $srcDir)
+  }
+  $pkgSource = $srcDir
+} else {
+  $pkgSource = "zocket"
+}
+
+$py = Resolve-Python
+$venvDir = Join-Path $InstallRoot "venv"
+$venvPy = Join-Path $venvDir "Scripts\python.exe"
+$zocketExe = Join-Path $venvDir "Scripts\zocket.exe"
+
+Run-Step $py.Cmd ($py.Prefix + @("-m", "venv", $venvDir))
+Run-Step $venvPy @("-m", "pip", "install", "--upgrade", "pip", "setuptools", "wheel")
+
+if ($Source -eq "PyPI") {
+  Run-Step $venvPy @("-m", "pip", "install", "--upgrade", $pkgSource)
+} else {
+  Run-Step $venvPy @("-m", "pip", "install", "--upgrade", $pkgSource)
+}
+
+Ensure-Dir $ZocketHome
+$env:ZOCKET_HOME = $ZocketHome
+
+if (-not (Test-Path -LiteralPath (Join-Path $ZocketHome "vault.enc"))) {
+  Run-Step $zocketExe @("init")
+}
+Run-Step $zocketExe @("config", "set-language", $Lang)
+
+if ($EnableAutostart) {
+  $webTask = "ZocketWeb"
+  $mcpSseTask = "ZocketMcpSse"
+  $mcpStreamTask = "ZocketMcpStreamable"
+
+  $webCmd = "`"$venvPy`" -m zocket web --host 127.0.0.1 --port $WebPort"
+  $mcpSseCmd = "`"$venvPy`" -m zocket mcp --transport sse --mode $McpMode --host 127.0.0.1 --port $McpPort"
+  $mcpStreamCmd = "`"$venvPy`" -m zocket mcp --transport streamable-http --mode $McpMode --host 127.0.0.1 --port $McpStreamPort"
+
+  schtasks /Create /F /SC ONLOGON /RL LIMITED /TN $webTask /TR $webCmd | Out-Null
+  schtasks /Create /F /SC ONLOGON /RL LIMITED /TN $mcpSseTask /TR $mcpSseCmd | Out-Null
+  schtasks /Create /F /SC ONLOGON /RL LIMITED /TN $mcpStreamTask /TR $mcpStreamCmd | Out-Null
+}
+
+Write-Output "zocket installed successfully."
+Write-Output "venv: $venvDir"
+Write-Output "zocket: $zocketExe"
+Write-Output "ZOCKET_HOME=$ZocketHome"
+Write-Output "web panel: http://127.0.0.1:$WebPort"
+Write-Output "mcp sse:   http://127.0.0.1:$McpPort/sse"
+Write-Output "mcp http:  http://127.0.0.1:$McpStreamPort/mcp"

package/scripts/install-zocket.sh

@@ -0,0 +1,228 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_ROOT="$(cd "${SCRIPT_DIR}/.." && pwd)"
+
+SOURCE_MODE="${SOURCE_MODE:-auto}"         # auto|local|git|pypi
+REPO_URL="${REPO_URL:-https://github.com/your-org/zocket.git}"
+REPO_REF="${REPO_REF:-main}"
+INSTALL_ROOT="${INSTALL_ROOT:-$HOME/.local/share/zocket}"
+ZOCKET_HOME_DIR="${ZOCKET_HOME_DIR:-$HOME/.zocket}"
+LANGUAGE="${LANGUAGE:-en}"                 # en|ru
+WEB_PORT="${WEB_PORT:-18001}"
+MCP_PORT="${MCP_PORT:-18002}"
+MCP_STREAM_PORT="${MCP_STREAM_PORT:-18003}"
+MCP_MODE="${MCP_MODE:-metadata}"           # metadata|admin
+AUTOSTART="${AUTOSTART:-user}"             # user|system|none
+SERVICE_USER="${SERVICE_USER:-zocketd}"
+
+usage() {
+  cat <<EOF
+Usage: $(basename "$0") [options]
+
+Options:
+  --source <auto|local|git|pypi>
+  --repo-url <git-url>
+  --repo-ref <branch-or-tag>
+  --install-root <path>
+  --zocket-home <path>
+  --lang <en|ru>
+  --web-port <port>
+  --mcp-port <port>
+  --mcp-stream-port <port>
+  --mcp-mode <metadata|admin>
+  --autostart <user|system|none>
+  --service-user <name>
+  -h, --help
+
+Environment variables with same names are also supported.
+EOF
+}
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --source) SOURCE_MODE="$2"; shift 2 ;;
+    --repo-url) REPO_URL="$2"; shift 2 ;;
+    --repo-ref) REPO_REF="$2"; shift 2 ;;
+    --install-root) INSTALL_ROOT="$2"; shift 2 ;;
+    --zocket-home) ZOCKET_HOME_DIR="$2"; shift 2 ;;
+    --lang) LANGUAGE="$2"; shift 2 ;;
+    --web-port) WEB_PORT="$2"; shift 2 ;;
+    --mcp-port) MCP_PORT="$2"; shift 2 ;;
+    --mcp-stream-port) MCP_STREAM_PORT="$2"; shift 2 ;;
+    --mcp-mode) MCP_MODE="$2"; shift 2 ;;
+    --autostart) AUTOSTART="$2"; shift 2 ;;
+    --service-user) SERVICE_USER="$2"; shift 2 ;;
+    -h|--help) usage; exit 0 ;;
+    *) echo "Unknown argument: $1" >&2; usage; exit 2 ;;
+  esac
+done
+
+have_cmd() {
+  command -v "$1" >/dev/null 2>&1
+}
+
+run_sudo() {
+  if have_cmd sudo; then
+    sudo "$@"
+  else
+    "$@"
+  fi
+}
+
+install_python_linux() {
+  if have_cmd apt-get; then
+    run_sudo apt-get update
+    run_sudo apt-get install -y python3 python3-venv python3-pip git curl
+    return
+  fi
+  if have_cmd dnf; then
+    run_sudo dnf install -y python3 python3-pip python3-virtualenv git curl
+    return
+  fi
+  if have_cmd yum; then
+    run_sudo yum install -y python3 python3-pip git curl
+    return
+  fi
+  if have_cmd pacman; then
+    run_sudo pacman -Sy --noconfirm python python-pip git curl
+    return
+  fi
+  if have_cmd zypper; then
+    run_sudo zypper install -y python3 python3-pip python3-virtualenv git curl
+    return
+  fi
+  if have_cmd apk; then
+    run_sudo apk add --no-cache python3 py3-pip py3-virtualenv git curl
+    return
+  fi
+  echo "Unsupported Linux package manager. Install Python 3.10+, pip, and venv manually." >&2
+  exit 1
+}
+
+install_python_macos() {
+  if ! have_cmd brew; then
+    echo "Homebrew not found. Install Homebrew first: https://brew.sh" >&2
+    exit 1
+  fi
+  brew install python git curl
+}
+
+OS="$(uname -s | tr '[:upper:]' '[:lower:]')"
+if ! have_cmd python3; then
+  echo "python3 not found, installing dependencies..."
+  case "$OS" in
+    linux*) install_python_linux ;;
+    darwin*) install_python_macos ;;
+    *)
+      echo "Unsupported OS for this installer: $OS" >&2
+      exit 1
+      ;;
+  esac
+fi
+
+if ! have_cmd git; then
+  echo "git not found, installing..."
+  case "$OS" in
+    linux*) install_python_linux ;;
+    darwin*) install_python_macos ;;
+    *) echo "Install git manually and rerun." >&2; exit 1 ;;
+  esac
+fi
+
+if [[ "$SOURCE_MODE" == "auto" ]]; then
+  if [[ -f "${REPO_ROOT}/pyproject.toml" ]]; then
+    SOURCE_MODE="local"
+  else
+    SOURCE_MODE="git"
+  fi
+fi
+
+PKG_SOURCE=""
+SRC_DIR="${INSTALL_ROOT}/src"
+
+mkdir -p "${INSTALL_ROOT}"
+
+if [[ "$SOURCE_MODE" == "local" ]]; then
+  PKG_SOURCE="${REPO_ROOT}"
+elif [[ "$SOURCE_MODE" == "git" ]]; then
+  if [[ -d "${SRC_DIR}/.git" ]]; then
+    git -C "${SRC_DIR}" fetch --all --tags
+    git -C "${SRC_DIR}" checkout "${REPO_REF}"
+    git -C "${SRC_DIR}" pull --ff-only
+  else
+    rm -rf "${SRC_DIR}"
+    git clone --depth 1 --branch "${REPO_REF}" "${REPO_URL}" "${SRC_DIR}"
+  fi
+  PKG_SOURCE="${SRC_DIR}"
+elif [[ "$SOURCE_MODE" == "pypi" ]]; then
+  PKG_SOURCE="zocket"
+else
+  echo "Invalid source mode: $SOURCE_MODE" >&2
+  exit 2
+fi
+
+VENV_DIR="${INSTALL_ROOT}/venv"
+PY_BIN="${VENV_DIR}/bin/python3"
+ZOCKET_BIN="${VENV_DIR}/bin/zocket"
+
+python3 -m venv "${VENV_DIR}"
+"${PY_BIN}" -m pip install --upgrade pip setuptools wheel
+
+if [[ "$SOURCE_MODE" == "pypi" ]]; then
+  "${PY_BIN}" -m pip install --upgrade "${PKG_SOURCE}"
+else
+  "${PY_BIN}" -m pip install --upgrade "${PKG_SOURCE}"
+fi
+
+mkdir -p "$HOME/.local/bin"
+ln -sf "${ZOCKET_BIN}" "$HOME/.local/bin/zocket"
+
+export ZOCKET_HOME="${ZOCKET_HOME_DIR}"
+mkdir -p "${ZOCKET_HOME_DIR}"
+
+if [[ ! -f "${ZOCKET_HOME_DIR}/vault.enc" ]]; then
+  "${ZOCKET_BIN}" init
+fi
+
+"${ZOCKET_BIN}" config set-language "${LANGUAGE}" >/dev/null
+
+if [[ "$AUTOSTART" == "user" && "$OS" == linux* ]]; then
+  "${ZOCKET_BIN}" autostart install \
+    --target both \
+    --web-port "${WEB_PORT}" \
+    --mcp-port "${MCP_PORT}" \
+    --mcp-mode "${MCP_MODE}" \
+    --zocket-home "${ZOCKET_HOME_DIR}" >/dev/null
+fi
+
+if [[ "$AUTOSTART" == "system" && "$OS" == linux* ]]; then
+  run_sudo env ZOCKET_HOME="${ZOCKET_HOME_DIR}" "${PY_BIN}" -m zocket harden install-linux-system \
+    --service-user "${SERVICE_USER}" \
+    --zocket-home "${ZOCKET_HOME_DIR}" \
+    --web-port "${WEB_PORT}" \
+    --mcp-host 127.0.0.1 \
+    --mcp-port "${MCP_PORT}" \
+    --mcp-mode "${MCP_MODE}" >/dev/null
+fi
+
+cat <<EOF
+zocket installed successfully.
+
+Runtime:
+  venv:      ${VENV_DIR}
+  zocket:    ${ZOCKET_BIN}
+  ZOCKET_HOME=${ZOCKET_HOME_DIR}
+
+Default ports:
+  web panel: http://127.0.0.1:${WEB_PORT}
+  MCP SSE:   http://127.0.0.1:${MCP_PORT}/sse
+  MCP HTTP:  http://127.0.0.1:${MCP_STREAM_PORT}/mcp
+
+Next steps:
+  1) Open web: ${ZOCKET_BIN} web --host 127.0.0.1 --port ${WEB_PORT}
+  2) MCP SSE (Claude Code): ${ZOCKET_BIN} mcp --transport sse --mode ${MCP_MODE} --host 127.0.0.1 --port ${MCP_PORT}
+  3) MCP Streamable (Codex): ${ZOCKET_BIN} mcp --transport streamable-http --mode ${MCP_MODE} --host 127.0.0.1 --port ${MCP_STREAM_PORT}
+  4) MCP stdio: ${ZOCKET_BIN} mcp --transport stdio --mode ${MCP_MODE}
+EOF

package/zocket/__init__.py

@@ -0,0 +1,2 @@
+__all__ = ["__version__"]
+__version__ = "1.0.0"

package/zocket/__main__.py

@@ -0,0 +1,5 @@
+from .cli import main
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())