deploy grokky
- Repo stars 0
- Author repo skills-registry
- Domain
- DevOps
- Author-declared agents
- No explicit declaration found; this is not inferred or tested compatibility
- Static check
- 88 / 100 · heuristic scan, not runtime safety proof
- Runtime evidence
- Not run; no isolated runtime test evidence is currently recorded
- Author / version / license
- @tomevault-io · no license declared
- Token usage
- Lean
- Setup complexity
- Manual integration
- External API key
- Required · Anthropic
- Operating systems
- Docker
- Runtime requirements
- Docker
- Detected file/system behavior
-
- Read-only
- Write / modify
- Shell exec
- Network behavior
- External requests
- Install commands
- None (reference only)
Heads up: Tool permissions are not declared; actual access depends on the runtime.
# Step 7 — Report results
- Whether Docker was started
- Whether grok_spawner was started
- Which images were built (or "all cached")
- Container statuses
- Publish result Run: If it fails: Then retry every 3 seconds (max 10 attempts): If still failing after 10 attempts: Stop execution and tell user: "Docker is not running. Please start Docker manually."
Check if running: If no output, start it: If running, check its age: Parse the timestamp and compare to now. If the container is older than 2 days, recreate it: Do NOT start any other services.
The network name varies by setup. Detect it from the running grok_spawner container: If `DOCKER_NETWORK` is empty, fall back: If still empty, stop and tell user: "No datagrok Docker network found. Is the platform running?"
Check existing images: Determine build flags: Build `claude-runtime` if: `dockerfiles/claude-runtime/` appears in `$CHANGED_FILES` OR `grokky-claude-runtime:admin` not found in `$EXISTING_IMAGES`
Step 5 — Build images (only those flagged in Step 4)
If build fails, stop and show the error output. If build succeeds: If publish fails, stop and show the error output.
Print: Whether Docker was started Whether grok_spawner was started Which images were built (or "all cached") Container statuses
# Deploy Grokky
This skill performs a full deployment of the Grokky package:
- Ensures Docker is running
- Ensures grok_spawner is running
- Builds required Docker images
- Starts runtime containers
- Builds and publishes the package
## Arguments
`$ARGUMENTS` may include:
- `key: <ANTHROPIC_API_KEY>`
- `host: <publish host>`
### Resolve arguments
1. If `host` is missing:
Ask: "Which host should I publish to? (e.g., `localhost`, `dev`, `public`)"
Wait for user input before continuing.
2. If `key` is missing:
Run:
```bash
echo $ANTHROPIC_API_KEY
```
If empty, ask the user to provide the key and wait.
## Resolve paths
Set variables explicitly:
```bash
GROKKY_ROOT=$(cd "${CLAUDE_SKILL_DIR}/../../.." && pwd)
DOCKER_DIR=$(cd "$GROKKY_ROOT/../../docker" && pwd)
COMPOSE_FILE="$DOCKER_DIR/localhost.bleeding-edge.docker-compose.yaml"
```
---
## Step 1 — Ensure Docker is running
Run:
```bash
docker info > /dev/null 2>&1
```
If it fails:
```bash
open -a Docker
```
Then retry every 3 seconds (max 10 attempts):
```bash
for i in {1..10}; do
sleep 3
docker info > /dev/null 2>&1 && break
done
```
If still failing after 10 attempts:
Stop execution and tell user: "Docker is not running. Please start Docker manually."
---
## Step 2 — Ensure grok_spawner is running and fresh
Check if running:
```bash
docker ps --filter "name=grok_spawner" --format "{{.Names}}"
```
If no output, start it:
```bash
cd "$DOCKER_DIR"
GROK_SPAWNER_CORE_MODE=true docker compose -f "$COMPOSE_FILE" up -d grok_spawner
```
If running, check its age:
```bash
docker inspect --format '{{.Created}}' grok_spawner
```
Parse the timestamp and compare to now. If the container is older than 2 days, recreate it:
```bash
cd "$DOCKER_DIR"
GROK_SPAWNER_CORE_MODE=true docker compose -f "$COMPOSE_FILE" up -d --force-recreate grok_spawner
```
Do NOT start any other services.
---
## Step 3 — Detect the Docker network
The network name varies by setup. Detect it from the running grok_spawner container:
```bash
DOCKER_NETWORK=$(docker ps --filter "name=grok_spawner" --format "{{.Networks}}" | head -1)
```
If `DOCKER_NETWORK` is empty, fall back:
```bash
DOCKER_NETWORK=$(docker network ls --format "{{.Name}}" | grep -E "datagrok" | head -1)
```
If still empty, stop and tell user: "No datagrok Docker network found. Is the platform running?"
---
## Step 4 — Detect required image builds
```bash
cd "$GROKKY_ROOT"
CHANGED_FILES=$(git diff --name-only HEAD -- dockerfiles/; git status --short -- dockerfiles/)
```
Check existing images:
```bash
EXISTING_IMAGES=$(docker images --format "{{.Repository}}:{{.Tag}}" | grep grokky || true)
```
Determine build flags:
- Build `claude-runtime` if:
- `dockerfiles/claude-runtime/` appears in `$CHANGED_FILES` OR
- `grokky-claude-runtime:admin` not found in `$EXISTING_IMAGES`
- Build `mcp-server` if:
- `dockerfiles/mcp-server/` appears in `$CHANGED_FILES` OR
- `grokky-mcp-server:admin` not found in `$EXISTING_IMAGES`
If neither needs building, skip to Step 6.
---
## Step 5 — Build images (only those flagged in Step 4)
### claude-runtime
```bash
cd "$GROKKY_ROOT/dockerfiles/claude-runtime"
docker build --build-arg ANTHROPIC_API_KEY=$KEY -t grokky-claude-runtime:admin .
docker rm -f grokky-claude-runtime 2>/dev/null || true
```
### mcp-server
```bash
cd "$GROKKY_ROOT/dockerfiles/mcp-server"
docker build -t grokky-mcp-server:admin .
docker rm -f grokky-mcp-server 2>/dev/null || true
```
---
## Step 6 — Build and publish
```bash
cd "$GROKKY_ROOT"
npm run build
```
If build fails, stop and show the error output.
If build succeeds:
```bash
grok publish $HOST
```
If publish fails, stop and show the error output.
---
## Step 7 — Report results
Print:
- Whether Docker was started
- Whether grok_spawner was started
- Which images were built (or "all cached")
- Container statuses
- Publish result
---
> Source: [datagrok-ai/public](https://github.com/datagrok-ai/public) — distributed by [TomeVault](https://tomevault.io).
<!-- tomevault:4.0:skill_md:2026-05-22 -->
Listed in source order.
sections -> Arguments → Resolve arguments → Resolve paths → Step 1 — Ensure Docker is running → Step 2 — Ensure grokspawner is running and fresh → Step 3 — Detect the Docker network
terms -> 1. If host is missing: Ask: "Which host should I publish to? · 2. If key is missing: Run: bash echo $ANTHROPICAPIKEY If empty, ask the user to provide the key and wait. · If still failing after 10 attempts: Stop execution and tell user: "Docker is not running. · Parse the timestamp and compare to now. · Do NOT start any other services. · The network name varies by setup. · If still empty, stop and tell user: "No datagrok Docker network found. · If neither needs building, skip to Step 6.
files/cmd -> $ARGUMENTS · key: <ANTHROPIC_API_KEY> · host: <publish host> · host · localhost · dev · public · key
body sha256 -> 130c12ea5c7c
Arguments
$ARGUMENTSmay include:key: <ANTHROPIC_API_KEY>host: <publish host>Resolve arguments
If
hostis missing: Ask: "Which host should I publish to? (e.g.,localhost,dev,public)" Wait for user input before continuing. Ifkeyis missing: Run:Resolve paths
Set variables explicitly:
Step 1 — Ensure Docker is running
Run: If it fails: Then retry every 3 seconds (max 10 attempts): If still failing after 10 attempts: Stop execution and tell user: "Docker is not running. Please start Docker manually."
Step 2 — Ensure grokspawner is running and fresh
Check if running: If no output, start it: If running, check its age: Parse the timestamp and compare to now. If the container is older than 2 days, recreate it: Do NOT start any other services.