🧽 OpenClaw Kitchen Sink Plugin

Credential-free OpenClaw plugin fixture that intentionally touches the public plugin API surface and works as a kitchen sink boilerplate for plugin authors.

This repo is both:

• a readable example for plugin authors
• a dummy compatibility fixture for Crabpot and plugin-inspector
• an npm-published plugin @openclaw/kitchen-sink for testing features

The generated runtime probes are credential-free. The hand-owned Kitchen Sink runtime also registers deterministic direct commands, tools, image generation, speech, realtime transcription/voice, video, music, media understanding, web search, web fetch, memory, compaction, gateway/service/CLI, channel, hook, and text-provider catalog surfaces. It should not call external services, read secrets, spawn processes, or require live credentials.

The plugin exposes three test personalities through plugins.entries.openclaw-kitchen-sink-fixture.config.personality:

• full is the default compatibility mode and keeps both generated probe registrations and the hand-owned runtime.
• conformance loads only the valid runtime surfaces and skips intentionally invalid probes so OpenClaw can assert a clean external-plugin install.
• adversarial loads only generated invalid probes so OpenClaw can assert expected diagnostics without mixing them with a live runtime smoke.

Source Layout

The hand-owned runtime is intentionally split by plugin surface so it can be used as reference code instead of one giant fixture file:

• src/index.js selects the Kitchen Sink personality and registers the runtime plus generated probes.
• src/kitchen-runtime.js is the runtime registrar entrypoint. It wires builders together but keeps the implementation in smaller modules.
• src/runtime/commands.js, channel.js, providers.js, and platform.js hold the command/tool, channel, provider, and service/gateway/CLI registrations.
• src/runtime/resources.js owns bounded calibration resources for one service registration; its RPC and service share the same owner.
• src/runtime/tasks.js keeps an in-memory detached-task helper for isolated fixture use. It is not registered on a live host.
• src/scenarios.js is the deterministic scenario router shared by dry commands, tools, providers, hooks, channel delivery, and tests.
• src/fixtures/ holds deterministic mock payloads such as the bundled image asset and text-provider stream fixture.
• src/generated-* files are diagnostic surface probes generated from the installed OpenClaw SDK. They are not the code plugin authors should copy.
• scripts/lib/ holds test harness code reused by runtime and contract probes; scripts/fixtures/ holds reviewable consumer-smoke programs.

Kitchen Runtime

The fixture can be used dry, without an LLM:

kitchen image generate a kitchen sink
kitchen image rate limit
kitchen image timeout
kitchen search kitchen sink provider routing
kitchen fetch kitchen://fixture/redirect
kitchen explain the fixture

It also exposes provider and tool surfaces for live model routing:

• listKitchenHumanScenarios() and runKitchenHumanScenario(runtime, id) provide deterministic end-to-end user scenarios for fixture consumers: dry.prefix-image, live.openai-text-kitchen-image, search.fetch.summarize, channel.prefix-image, hook.block-tool, and memory.compact-fixture.

• When a live text provider such as OpenAI is active and Kitchen Sink is selected as the image provider, the live.openai-text-kitchen-image scenario proves the human prompt can route to the Kitchen Sink image provider and return the bundled kitchen_sink_office.png asset without external image credentials.

• The hook.block-tool scenario proves terminal before_tool_call blocking, and the contract probe script also checks the approval path and conversation privacy observations for llm_input, llm_output, and agent_end.

• src/scenarios.js routes deterministic user scenarios; reusable mock payloads live in src/fixtures/.

• kitchen_sink_image_job returns a deterministic image job, waits 10 seconds in real runtime execution, then returns the bundled kitchen_sink_office.png image payload with PNG dimensions, byte size, SHA-256 hash, seed, model, and finish metadata.

• kitchen-sink-image is a registered image generation provider with aliases kitchen, kitchen-sink, and openclaw-kitchen-sink; prompts containing rate limit, timeout, or fail exercise deterministic provider error paths.

• kitchen-sink-media describes images with deterministic fixture text.

• kitchen-sink-speech, kitchen-sink-realtime-transcription, kitchen-sink-realtime-voice, kitchen-sink-video, and kitchen-sink-music expose credential-free media provider fixtures with deterministic WAV, transcript, bridge, storyboard, and track payloads. Realtime transcription counts bytes as audio arrives without retaining the audio buffers; callers can reuse or transfer their storage after sendAudio.

• kitchen-sink-search and kitchen-sink-fetch provide credential-free web tool fixtures with realistic status codes, request ids, result metadata, redirects, headers, cache metadata, links, and markdown content.

• kitchen-sink-embedding, kitchen-sink-memory-corpus, and kitchen-sink-compaction provide deterministic memory vectors, corpus results, reads, and transcript summaries.

• kitchen-sink-channel is a credential-free channel fixture that can resolve local ready/disabled/misconfigured accounts, route outbound sessions, and deliver deterministic text/media records. Configure it under channels["kitchen-sink-channel"]: enabled: false or disabled: true disables the account; configured: false marks it as needing setup. Setup and runtime status use the same account state.

• kitchen.status, /kitchen-sink/status, kitchen-sink-service, and the lazy CLI descriptor exercise gateway method, HTTP route, service, and CLI registration surfaces.

• kitchen-sink-llm exposes a deterministic text-provider catalog row, provider-owned stream function, and prompt guidance so live LLM providers can discover the Kitchen Sink routes; responses describe which real plugin surface would handle image, search, fetch, and failure prompts.

• kitchen-sink-embedding exercises the current generic embedding adapter contract used by memory and search callers.

• generated hooks classify Kitchen Sink prompts, tool calls, and provider selections into shared scenario ids such as image.generate, web.search, and text.reply.

• buildKitchenDetachedTaskRuntime() records task transitions in memory for isolated fixture tests only. Kitchen Sink does not replace OpenClaw's detached task lifecycle: native image/music jobs must remain in the host's durable store so task status lookups can find them.

Resource Calibration

The kitchen.resources Gateway method supplies known work for CPU, memory, and lifecycle profiling in full and conformance personalities. Call it through an authenticated Gateway operator session with the default admin scope. Empty parameters ({}) only return status; registration and service start allocate no calibration resources. CPU work and acquisition require kitchen-sink-service to be started by the host.

| Parameters | Effect / hard limit | | --- | --- | | {} | Read active state, held bytes, timer state/interval/ticks, and last CPU result. | | {"action":"cpu","iterations":1000000} | Run 1–10,000,000 fixed mixing iterations; return an observable checksum. | | {"action":"buffer","bytes":8388608} | Hold one filled Buffer, 1–67,108,864 bytes (64 MiB). | | {"action":"timer","intervalMs":100} | Hold one referenced interval, 10–60,000 ms; increment a tick counter. | | {"action":"release","resource":"buffer"} | Release the held Buffer. "timer" clears the interval and its counter. | | {"action":"reset"} | Release both resources and clear counters/results, preserving service state. |

Unknown fields, missing/invalid bounds, and duplicate resource acquisitions return INVALID_REQUEST without mutation. Work while stopped returns UNAVAILABLE. Release/reset are idempotent, including while stopped. Service stop synchronously releases both resources and clears results; a restarted service begins empty. Registrations never share these resources.

These are clean controls, not intentional leak fixtures. A released Buffer is eligible for collection; RSS need not fall immediately. Status is fixture state, not a CPU/heap measurement. The profiling harness owns measurement, drain/GC policy, and comparison with an empty host. Process exit alone is not proof of in-process service cleanup.

API Surface Sync

The generated fixture is derived from the exact dev-pinned openclaw package. The published plugin declares that host as an optional peer: npm does not install another OpenClaw runtime, while the OpenClaw installer links the active host into the plugin's module graph. It extracts the public openclaw/plugin-sdk/* surface from:

• registrar methods
• hook names
• manifest contract fields
• exported plugin SDK subpaths

The declaration reader supports both object-shaped manifest contracts and the key-tuple-based contracts published by OpenClaw 2026.10.1. It refuses to generate an empty surface if a required declaration cannot be read.

It then writes explicit static evidence for those surfaces: hook registrations, registrar calls with no-op callback payloads, SDK import coverage, and manifest contract coverage.

Expected rejection diagnostics follow the discovered registrars, including the intentionally invalid agent-executor controller probe in OpenClaw 2026.10.5. The conformance personality continues to register only valid runtime surfaces.

registerDetachedTaskRuntime is discovered but intentionally not exercised on a live host. Registering the in-memory helper would replace the host's durable task lifecycle globally. The shared surface metadata records this exclusion and its reason; for [email protected], checks report 57 discovered registrars and 56 runtime registrar probes. Probe presence is not proof that every capability is valid or has been exercised end to end.

npm install
npm run sync:surface
npm run check:runtime
npm run check:inspector
npm run check:install
npm run pack:check
npm run pack:zip

Development uses Node 24.16.0 or a newer Node 24 patch release; CI pins Node 24.21.0. CI runs the full checks with both npm 10 and npm 12, including the installed-package smoke and package payload validation.

The middleware-host check keeps its disposable home and state until the process exits, including asynchronous host cleanup. Its regression probe verifies that a synthetic caller profile and database remain untouched.

The Update OpenClaw SDK Surface workflow automatically checks openclaw@latest and @openclaw/plugin-inspector@latest every 10 minutes. When either package changes, it regenerates the pinned dependency, lockfile, manifest, hooks, registrars, and SDK import fixture files, runs the static and runtime plugin-inspector checks, then creates and squash-merges its own automation PR after those checks pass.

Dependabot still watches npm dependencies, but ignores openclaw and @openclaw/plugin-inspector because those updates should flow through the generated updater instead of package-only bump PRs. TypeScript stays on 6.x because the SDK declaration reader uses its compiler API; TypeScript 7 removes that API. Major TypeScript updates are held until the reader has a supported replacement.

Publishing

Tagged GitHub releases publish the validated package to npm through trusted publishing. The release tag must match package.json, for example v0.0.1 for version 0.0.1.

npm pack remains the canonical npm artifact. npm run pack:zip builds the legacy archive artifact at dist/openclaw-kitchen-sink-fixture-<version>.zip with package.json, openclaw.plugin.json, plugin-inspector.config.json, README.md, and src/** at the archive root for old archive installers.

Land the version, generated surface, and finalized changelog in a release-prep PR, then run the Release workflow with dry_run on the merged commit. Sign the annotated release tag with the fleet release key and verify it against .github/release-allowed-signers before pushing. Create the GitHub release with the finalized changelog notes; publishing it runs the npm publish workflow. 0.0.x verification releases publish under the verification npm dist-tag so they do not replace the stable latest tag.

To validate a release without publishing, dispatch the Release workflow on the branch to check, set tag to v followed by its current package version, and enable dry_run. This checks the selected branch even when the version is already published, runs the release checks, and uploads the packed artifact without creating a tag or publishing to npm.

The package is intentionally not listed on ClawHub. The OpenClaw repository's ClawHub install tests use a local fixture server, while this repository continues to publish the live test plugin to npm.