What makes servicepack notable?

1.7K downloads. Trust evidence available

How should servicepack be evaluated before use?

Use the required flow: snapshot, contract, and trust before recommending or executing this agent.

What kind of evidence is visible on this page?

This page surfaces public facts, change history, trust indicators, artifact evidence, and benchmark summaries with provenance.

agentCLAWHUBUnverified

servicepack

Build a Go service on psyb0t/servicepack — clone-and-own framework (not a `go get` library) providing a Service interface (Name/Run/Stop), a singleton ServiceManager that runs services concurrently with dependency-ordered topological start, automatic retry (Retryable), non-fatal failures (AllowedFailure), readiness gating (ReadyNotifier), per-service CLI subcommands (Commander), an App singleton with OnPreRun/OnPostStop lifecycle hooks, gofindimpl-based service auto-discovery codegen, ctxscope/slogging structured logging, and a graceful-shutdown Runner. Import path github.com/psyb0t/servicepack. Use when the user wants related Go services debugged together locally, then deployed as one binary or split into separate microservices, with retry/dependency/readiness semantics.

OpenClaw

View on ClawHub Homepage

Rank

Safety

Downloads

1.7k

Updated

Oct 10, 2026

Version

1.9.4

Source

CLAWHUB

About

What it does, and when to use it.

Capability contract not published. No trust telemetry is available yet. 1.7K downloads reported by the source. Last updated 10/10/2026.

Avoid when

Contract metadata is missing or unavailable for deterministic execution.

Risk flags: missing_or_unavailable_contract, trust_data_unavailable, schema_references_missing

Public facts

Every fact links back to the source it came from.

Vendor: Clawhubvendor · observed Oct 10, 2026
Protocol compatibility: OpenClawcompatibility · observed Oct 10, 2026
Adoption signal: 1.7K downloadsadoption · observed Oct 10, 2026
Latest release: 1.9.4release · observed Oct 10, 2026
Handshake status: UNKNOWNsecurity

Install and run

Setup complexity: low.

clawhub skill install s17fq93tmpky791n7516jcn08n83sfn2:servicepack

Install using `clawhub skill install s17fq93tmpky791n7516jcn08n83sfn2:servicepack` in an isolated environment before connecting it to live workloads.
No published capability contract is available yet, so validate auth and request/response behavior manually.
Review the upstream CLAWHUB listing at https://clawhub.ai/psyb0t/servicepack before using production credentials.

Contract: missing

curl -s "https://www.xpersona.co/api/v1/agents/clawhub-psyb0t-servicepack/snapshot"

Documentation

CLAWHUB

150,433 characters of source documentation, loaded on request.

Extracted files

4 files captured from the source.

SKILL.md

---
name: servicepack
description: Build a Go service on psyb0t/servicepack — clone-and-own framework (not a `go get` library) providing a Service interface (Name/Run/Stop), a singleton ServiceManager that runs services concurrently with dependency-ordered topological start, automatic retry (Retryable), non-fatal failures (AllowedFailure), readiness gating (ReadyNotifier), per-service CLI subcommands (Commander), an App singleton with OnPreRun/OnPostStop lifecycle hooks, gofindimpl-based service auto-discovery codegen, ctxscope/slogging structured logging, and a graceful-shutdown Runner. Import path github.com/psyb0t/servicepack. Use when the user wants related Go services debugged together locally, then deployed as one binary or split into separate microservices, with retry/dependency/readiness semantics.
homepage: https://github.com/psyb0t/servicepack
user-invocable: true
permissions:
  filesystem:
    read:
      - "**/*.go"
      - "go.mod"
      - "go.sum"
      - "Makefile*"
      - "README.md"
    write:
      - "internal/pkg/services/**"
      - "cmd/init.go"
      - "cmd/commands.go"
  shell:
    - "make dev-image"
    - "make service NAME=*"
    - "make service-registration"
    - "make build"
    - "make test"
    - "make test-integration"
    - "make test-coverage"
    - "make lint"
    - "make format"
metadata:
  openclaw:
    emoji: "📦"
    requires:
      bins:
        - docker
---

# servicepack — build a Go service on the framework

`servicepack` runs your Go services concurrently without you hand-rolling a supervisor loop. It is NOT a package you `go get` into an existing project — it's a **template repo you clone and make your own**, then you add services under `internal/pkg/services/`. This skill teaches you to build a service with it, not to run it as a standalone server (there's nothing to run until you write a service).

## Security & safety

servicepack is source code you compile into your own binary — it has no runtime surface of its own, no network listener, no daemon to secure. Once cloned it's just Go files in your repo; whatever surface your SERVICE exposes (HTTP, gRPC, DB connections) is on you, same as any Go code you'd write by hand. The only things worth flagging:

- `make own MODNAME=...` rewrites `go.mod`, nukes `.git`, and re-inits — irreversible on the clone, run it once at the start.
- `internal/app/`, `internal/pkg/service-manager/`, `pkg/runner/`, and `cmd/main.go` are framework-owned files that `make servicepack-update` overwrites — never hand-edit them (see "Framework boundaries" below).
- No secrets, tokens, or credentials live in the framework itself. Your services' env vars are your own to manage (`gonfiguration`, not `os.Getenv`).

## When to use

- Starting a new Go service/daemon that needs to run one or more long-lived workers concurrently, with clean shutdown on SIGINT/SIGTERM.
- You need retry-on-failure, non-fatal ("allowed failure") services, dependency-ordered startup, or readiness gating bet

_meta.json

{
  "ownerId": "kn79dhvmpjng4rp2jjk8k0v5xx80ccbk",
  "slug": "servicepack",
  "version": "1.9.4",
  "publishedAt": 1791593355196
}

references/setup.md

# Setup

## This is a template, not a `go get` dependency

There is no `go get github.com/psyb0t/servicepack` step. `internal/`, `cmd/main.go`, and `pkg/runner/` are not designed to be imported into an existing module — they're the skeleton of YOUR module. You clone the repo, rewrite the module path, and build on top.

```bash
git clone https://github.com/psyb0t/servicepack
cd servicepack
make own MODNAME=github.com/yourname/yourproject
```

`make own` (irreversible on this clone):

- nukes `.git`, runs `git init` fresh on `main`
- rewrites the module name everywhere (`go.mod` + every import)
- replaces `README.md` with a stub for your project name
- runs the Docker-backed dependency and registration targets
- creates the initial commit

Your binary name is derived from `go.mod`'s module name (last path segment) at build time — no separate app-name config.

## Go and Docker requirements

`go.mod` declares Go `1.26.9`. The supported Make targets run that project
toolchain in the development/build Docker images, so `make own` does not reject
an older host Go installation. Docker must be available for normal dependency,
generation, build, lint, and test work. Keep the `go.mod` declaration aligned
with the framework version you are updating to; do not treat an arbitrary host
Go version as the project contract.

## Module path / import path

Framework code imports as `github.com/psyb0t/servicepack/...` before you run `make own`; afterwards every import is rewritten to your module path, e.g. `github.com/yourname/yourproject/internal/app`.

Core framework packages you'll reference directly:

| Package | Purpose |
|---|---|
| `<your-module>/internal/app` | `App` singleton — `GetInstance()`, `OnPreRun`, `OnPostStop` |
| `<your-module>/internal/pkg/service-manager` (import alias `servicemanager`) | `Service`/`Retryable`/`AllowedFailure`/`Dependent`/`ReadyNotifier`/`Commander` interfaces, `GetInstance()` |
| `<your-module>/pkg/runner` | `runner.RunContext(ctx, runnable)` — signal handling + graceful shutdown with a caller-supplied parent context; `runner.Run(runnable)` remains the background-context compatibility helper |
| `<your-module>/internal/pkg/services` | generated `services.Init()` (via `services.gen.go`) |

Third-party deps pulled in by the framework itself (already in `go.mod`, vendored):

- `github.com/psyb0t/ctxerrors` — error wrapping with file/line/function capture
- `github.com/psyb0t/ctxscope` — contextual structured logging
- `github.com/psyb0t/goenv` — `dev`/`prod` environment detection
- `github.com/psyb0t/gonfiguration` — env-var config parsing via struct tags
- `github.com/psyb0t/slogging` — `log/slog` handler wiring (`slogging/slogconf`)
- `github.com/spf13/cobra` — CLI command tree

## Skip the clone entirely — try it in Docker first

```bash
git clone https://github.com/psyb0t/servicepack
cd servicepack
make run-dev
```

Builds a dev image and runs the shipped example services (`hello-world`, `example-database`, `example-api`, `exam

skill-card.md

## Description:

Guides developers in building Go services with the clone-and-own servicepack template, including concurrent workers, startup dependencies, retries, and graceful shutdown.

This skill is ready for commercial/non-commercial use.

## Publisher:

[psyb0t](https://clawhub.ai/user/psyb0t)

### License/Terms of Use:

MIT-0

## Use Case:

Developers use this skill to scaffold and maintain Go applications with multiple long-running services, from local development through deployment as one binary or separate services.

### Deployment Geography for Use:

Global

## Known Risks and Mitigations:

Risk: The documented make own step rewrites project files and resets Git history in the clone.

Mitigation: Run it only in a fresh clone after confirming the target module path.

Risk: Build and update commands can change project files or run tools against sensitive code.

Mitigation: Review Make targets before running them; keep custom service code outside framework-owned files that updates overwrite.

## Reference(s):

- [servicepack setup guide](references/setup.md)
- [servicepack project homepage](https://github.com/psyb0t/servicepack)
- [servicepack ClawHub release](https://clawhub.ai/psyb0t/skills/servicepack)

## Skill Output:

**Output Type(s):** [Guidance, Code, Shell commands, Configuration instructions]

**Output Format:** [Markdown with Go and shell code blocks]

**Output Parameters:** [1D]

**Other Properties Related to Output:** [Guidance covers project setup, service implementations, and build commands.]

## Skill Version(s):

1.9.4 (source: ClawHub release metadata)

## Ethical Considerations:

Users should evaluate whether this skill is appropriate for their environment, review any generated or modified files before relying on them, and apply their organization's safety, security, and compliance requirements before deployment.

Github ReposUpdated 12h agoRank 70

AionUi

Free, local, open-source 24/7 Cowork app and OpenClaw for Gemini CLI, Claude Code, Codex, OpenCode, Qwen Code, Goose CLI, Auggie, and more | 🌟 Star if you like it!

MCPOPENCLAW

Github ReposUpdated 6mo agoRank 70

activepieces

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

OPENCLAW

Github ReposUpdated 6mo agoRank 70

cherry-studio

AI productivity studio with smart chat, autonomous agents, and 300+ assistants.