deploy-grokky

DevOps Community

Repo stars 0
Author repo skills-registry

Interpretation is structured for decision-making; original keeps the upstream SKILL.md unchanged.

Decide Fit First

Core job: Deploy Grokky — start Docker, ensure grok_spawner, build images, publish package Use when this capability is needed. This skill…
Best fit: Use it when the task has reusable inputs, steps, and validation criteria rather than a one-off answer.
Avoid forcing it: If the source lacks commands, platform support, or external-service evidence, keep those fields unknown instead of guessing.

Design Intent

Structure: The skill is organized around “Arguments”, “Resolve arguments”, “Resolve paths”, “Step 1 — Ensure Docker is running”, showing how the author expects the agent to judge fit, collect context, and produce verifiable output.
Trigger evidence: Prioritize the author’s wording around when to use it, what context to collect, and what output shape to produce.
Evidence boundary: Author text states facts, repository files prove commands and paths, and Fluxly only adds fit, limits, and usage judgment.

How To Use It

Inputs: Provide target material, scope, expected result, forbidden changes, and validation method.
Invocation: Name deploy-grokky directly; if the source includes slash commands, start with the command and then add task context.
Validation: Start small and check whether the result follows “Arguments / Resolve arguments / Resolve paths” before expanding.

Boundaries And Review

Dependencies: Prepare Anthropic API keys before running a full task.
Permissions: Declared permissions include read / write / shell-exec; ask the agent to state file, command, and rollback boundaries before acting.
Quality bar: A useful result names the deliverable, evidence, and next action. Generic prose means the task needs tighter context.

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

If host is missing: Ask: "Which host should I publish to? (e.g., localhost, dev, public)" Wait for user input before continuing.
If key is missing: Run:
```
echo $ANTHROPIC_API_KEY
```
If empty, ask the user to provide the key and wait.

Resolve paths

Set variables explicitly:

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:

docker info > /dev/null 2>&1

If it fails:

open -a Docker

Then retry every 3 seconds (max 10 attempts):

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:

docker ps --filter "name=grok_spawner" --format "{{.Names}}"

If no output, start it:

cd "$DOCKER_DIR"
GROK_SPAWNER_CORE_MODE=true docker compose -f "$COMPOSE_FILE" up -d grok_spawner

If running, check its age:

docker inspect --format '{{.Created}}' grok_spawner

Parse the timestamp and compare to now. If the container is older than 2 days, recreate it:

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:

DOCKER_NETWORK=$(docker ps --filter "name=grok_spawner" --format "{{.Networks}}" | head -1)

If DOCKER_NETWORK is empty, fall back:

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

cd "$GROKKY_ROOT"
CHANGED_FILES=$(git diff --name-only HEAD -- dockerfiles/; git status --short -- dockerfiles/)

Check existing images:

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

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

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

cd "$GROKKY_ROOT"
npm run build

If build fails, stop and show the error output.

If build succeeds:

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 — distributed by TomeVault.

Fluxly profile Author and license come from source; runtime, permissions, and network are Fluxly detections or estimates

Fluxly category: 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
Author / version / license: @tomevault-io · no license declared
Fluxly token estimate: Lean
Fluxly setup estimate: Manual integration
External API key: Required · Anthropic
Detected OS requirements: Docker
Runtime requirements: Docker
Detected file/system behavior: Read-only
Write / modify
Shell exec
Detected network behavior: External requests
Install commands: None (reference only)

Profile is derived at build time from SKILL.md and install vectors. Subject to drift from author intent.

Heads up: 未限定 allowed-tools，默认拥有全部工具权限。

Output preview deploy-grokky.preview

# Step 7 — Report results

- Whether Docker was started
- Whether grok_spawner was started
- Which images were built (or "all cached")
- Container statuses
- Publish result

SKILL.md SKILL.md

# 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"

…

Evidence boundary and execution chain

Author text anchors workflow facts; Fluxly only indexes current sections, terms, files, and commands.

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: <ANTHROPICAPIKEY> · host: <publish host> · host · localhost · dev · public · key
body sha256 -> 130c12ea5c7c