Spin

https://github.com/spinframework/spin-docs
Admin
Spin is a framework for building and running event-driven microservice applications with WebAssembly...
Tokens:72,477
Snippets:743
Trust Score:-
License:Apache-2.0
Update:6 days ago
Show doc for...
Tokens:
Raw
### Initialize and start the 11ty application

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/sample_11ty.md

Commands to install dependencies and start the development server after creating a repository from the template.

```bash
npm install
npx start
```

--------------------------------

### Build and run the website locally

Source: https://github.com/spinframework/spin-docs/blob/main/README.md

Commands to install dependencies and start the Spin development server with hot reloading.

```bash
cd spin-up-hub
npm ci
cd ../
npm ci
spin build
spin watch # Uses spin watch to run the website and reload when content changes.
```

--------------------------------

### Install and Run Docusaurus Template

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/template_docusaurus.md

Commands to install dependencies, start the development server, or build and run the application using Spin.

```bash
npm install
npx start
```

```bash
spin build
spin up
```

--------------------------------

### Run the application with OTel tooling

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/announcing-spin-3-6.md

Commands to install the OTel plugin, start the collector, and run the application.

```bash
# Install the `otel` plugin
spin plugin update
spin plugin install otel

# Start the OpenTelemetry collector in the background
spin otel setup

# Run Spin wired up to the OTel collector
spin otel up -- --build --experimental-wasi-otel

# In another terminal
curl localhost:3000
```

--------------------------------

### Install pluginify

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/plugin_spin_pluginify.md

Use this command to install the pluginify plugin for Spin.

```bash
spin plugins install pluginify
```

--------------------------------

### Install custom Spin templates

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/component-composition-spin-4-0.md

Install the headless-rust template from the specified GitHub repository.

```bash
spin templates install \
  --git https://github.com/ThorstenHans/spin-headless-components
```

--------------------------------

### Run HTTP middleware example

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/announcing-spin-4-1.md

Commands to clone the Spin repository and run the HTTP middleware example.

```console
$ git clone https://github.com/spinframework/spin
$ cd spin/examples/http-middleware
$ spin build --up
```

--------------------------------

### Install Spin Message Trigger plugin

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/plugin_spin_message_trigger.md

Run this command to install the plugin on your system.

```bash
spin plugin install --url https://github.com/lee-orr/spin-message-trigger/releases/download/canary/trigger-message.json --yes
```

--------------------------------

### Install Spinlet with git clone and spin pluginify

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/plugin_spinlet.md

Installation commands for Spinlet. Requires Rust >= 1.70.0, Spin >= 1.2.0, wasm-tools >= 1.0.35, wit-bindgen >= 0.7.0, and spin-pluginify >= PR #6. Run these commands in sequence to clone the repository, enter the directory, install the plugin, and run it.

```bash
git clone https://github.com/cardoso/spinlet
cd spinlet
spin pluginify -i
spin let
```

--------------------------------

### Configure and start the Spin application

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/sample_openaichat_ts.md

Set the OpenAI API key as an environment variable and start the Spin application.

```bash
$ export SPIN_CONFIG_OPENAI_KEY=$YOUR_OPENAI_KEY 
$ spin build --up
Serving http://127.0.0.1:3000
Available Routes:
  openai-chat-ts: http://127.0.0.1:3000/question
```

--------------------------------

### Set up the Spin OTel dashboards

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/plugin_spin_otel.md

Runs the setup command to initialize the dashboards for the OTel plugin.

```sh
spin otel setup
```

--------------------------------

### Install the WASIp3 Spin template

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/announcing-spin-3-5.md

Install the template from the spinframework/spin repository using the --upgrade flag.

```console
$ spin templates install --upgrade --git https://github.com/spinframework/spin
```

--------------------------------

### Install the NuxtJS template

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/template_nuxt.md

Use this command to install the NuxtJS template from the specified GitHub repository.

```bash
$ spin templates install --upgrade --git https://github.com/VamshiReddy02/spin-nuxt
```

--------------------------------

### Build and Run the Cron Application

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/plugin_spin_cron_trigger.md

Navigate to the application directory and start the application.

```bash
cd hello-cron
spin build --up
```

--------------------------------

### Install the Spin Cloud GPU plugin

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/plugin_spin_cloud_gpu.md

Use this command to install the cloud-gpu plugin from the specified canary release URL.

```bash
spin plugins install -u https://github.com/fermyon/spin-cloud-gpu/releases/download/canary/cloud-gpu.json -y
```

--------------------------------

### GitHub Actions workflow configuration for keyless signing

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/spin-gh-plugin-update.md

Example workflow configuration showing the required id-token: write permission, cosign installation, and the signing steps for OCI artifacts.

```yaml
name: "CI"
# ...
jobs:
  spin:
    # ...
    permissions:
      contents: read
      packages: write
      id-token: write
    steps:
      - name: Install Cosign
        uses: sigstore/cosign-installer@v3
        # ...
      - name: Authenticate against OCI registry for app-one
        run: |
          spin registry login -u ${{ github.actor }} -p ${{ secrets.GITHUB_TOKEN }} ghcr.io
          docker login -u ${{ github.actor }} -p ${{ secrets.GITHUB_TOKEN }} ghcr.io
      - name: Push OCI Artifact for app-one
        # ...
      - name: Sign OCI Artifact for app-one
        working-directory: ./app-one
        run: |
          cosign sign --yes ghcr.io/thorstenhans/tmp-app-one:latest
      - name: Authenticate against OCI registry for app-two
        run: |
          spin registry login -u ${{ github.actor }} -p ${{ secrets.GITHUB_TOKEN }} ghcr.io
          docker login -u ${{ github.actor }} -p ${{ secrets.GITHUB_TOKEN }} ghcr.io
      - name: Push OCI Artifact for app-two
        # ...
      - name: Sign OCI Artifact for app-two
        working-directory: ./app-two
        run: |
          cosign sign --yes ghcr.io/thorstenhans/tmp-app-two:latest
```

--------------------------------

### Install Spin Message Trigger templates

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/plugin_spin_message_trigger.md

Install the available templates to quickly scaffold new projects and components.

```bash
spin templates install --git https://github.com/lee-orr/spin-message-trigger --upgrade
```

--------------------------------

### Create a new message-app project

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/plugin_spin_message_trigger.md

Initialize a new project using the installed message-app template.

```bash
spin new message-app
```

--------------------------------

### Install Kinesis Template

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/plugin_spin_kinesis_trigger.md

Installs the Kinesis template from the GitHub repository.

```sh
spin templates install --update --git https://github.com/ogghead/spin-trigger-kinesis
```

--------------------------------

### Install the SQLite explorer template

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/template_sqlite_explorer.md

Use the Spin CLI to install or upgrade the SQLite explorer template from the specified GitHub repository.

```bash
spin templates install --upgrade --git https://github.com/karthik2804/spin-sqlite-web-cli/
```

--------------------------------

### Install the KV explorer template

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/template_kv_explorer.md

Use this command to install or upgrade the KV explorer template from the specified GitHub repository.

```sh
spin templates install --upgrade --git https://github.com/fermyon/spin-kv-explorer
```

--------------------------------

### Install Zola template

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/template_zola_ssg.md

Use the Spin CLI to install the Zola template from the specified GitHub repository.

```bash
$ spin templates install --upgrade --git https://github.com/karthik2804/spin-zola
```

--------------------------------

### Run the MCP server using spin.toml

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/mcp-with-wasmcp.md

Start the MCP server using the configuration defined in spin.toml.

```shell
spin up --from spin.toml
```

--------------------------------

### Install the Spin Cron Template

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/plugin_spin_cron_trigger.md

Use this command to install the template required for creating cron-based Spin applications.

```bash
spin templates install --git https://github.com/spinframework/spin-trigger-cron
```

--------------------------------

### Install wasmcp via script

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/mcp-with-wasmcp.md

Use this command to install the latest release binary of wasmcp.

```shell
curl -fsSL https://raw.githubusercontent.com/wasmcp/wasmcp/main/install.sh | bash
```

--------------------------------

### Install the Spin Cron Trigger Plugin

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/plugin_spin_cron_trigger.md

Use this command to install the experimental cron trigger plugin from the specified URL.

```bash
spin plugins install --url https://github.com/spinframework/spin-trigger-cron/releases/download/canary/trigger-cron.json
```

--------------------------------

### Example Git remote output

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/contributing.md

Example output showing the origin and upstream remote configurations.

```text
origin	git@github.com:yourusername/spin-docs.git (fetch)
origin	git@github.com:yourusername/spin-docs.git (push)
upstream	https://github.com/spinframework/spin-docs (fetch)
upstream	https://github.com/spinframework/spin-docs (push)
```

--------------------------------

### Install check-for-update plugin

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/plugin_check_for_update.md

Use this command to install the check-for-update plugin via the Spin CLI.

```bash
spin plugins install --url https://raw.githubusercontent.com/spinframework/spin-plugins/main/manifests/check-for-update/check-for-update.json
```

--------------------------------

### Install js2wasm plugin

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/plugin_js2wasm.md

Use this command to install the js2wasm plugin for legacy Spin projects.

```bash
spin plugins install js2wasm
```

--------------------------------

### Test Spin Hub locally

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/contributing.md

Commands to install dependencies, build the project, and run the local development server.

```console
$ npm install
$ cd spin-up-hub
$ npm install
$ cd ..
$ spin build
$ npm run spin
```

--------------------------------

### WebAssembly sandbox rejection example

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/deepfabric-spin.md

An example of how the WebAssembly sandbox denies unauthorized file system access and returns an error.

```text
Agent: read_file("/etc/passwd")
Wasm:  {"success": false, "result": "Access denied", "error_type": "PermissionDenied"}
```

--------------------------------

### Install wasm32-wasip2 Rust target

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/sample_http_auth_middleware.md

Install the required Rust target for compiling the middleware component.

```bash
rustup target add wasm32-wasip2
```

--------------------------------

### Install Kinesis Trigger Plugin

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/plugin_spin_kinesis_trigger.md

Installs the experimental Kinesis trigger plugin from the canary release URL.

```sh
spin plugins install --url https://github.com/ogghead/spin-trigger-kinesis/releases/download/canary/trigger-kinesis.json
```

--------------------------------

### Go component using standard toolchain

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/announcing-spin-4-0.md

Example of a Spin Go component using the v3 SDK, which no longer requires TinyGo and builds with the standard Go toolchain.

```go
package main

import (
    "fmt"
    "net/http"

    spinhttp "github.com/spinframework/spin-go-sdk/v3/http"
)

func init() {
    spinhttp.Handle(func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("content-type", "text/plain")
        fmt.Fprintln(w, "Hello from Go on WASIp3!")
    })
}

func main() {}
```

--------------------------------

### Run application in development mode

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/sample_weather_data_aggregator.md

Commands to set environment variables, start the Spin application, and test the API endpoint with sample data.

```sh
export SPIN_VARIABLE_KV_EXPLORER_USER=demo
export SPIN_VARIABLE_KV_EXPLORER_PASSWORD=demo
export SPIN_VARIABLE_API_TOKEN=demo
spin up --build --runtime-config-file runtime_config.toml
curl -X POST -d @api/examples/mixed.json 'http://127.0.0.1:3000/api/v1?token=demo'
```

--------------------------------

### Run static file server with spin up and test with curl

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/template_spin_fileserver.md

Starts the static file server on 127.0.0.1:3000 using the spin.toml file. The server serves all files in the current directory. The curl command retrieves the LICENSE file, showing the server's response.

```bash
$ spin up --listen 127.0.0.1:3000 --file spin.toml
```

```bash
$ curl localhost:3000/LICENSE
                              Apache License
                        Version 2.0, January 2004
                    http://www.apache.org/licenses/

TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
...
```

--------------------------------

### Development and Build Commands

Source: https://github.com/spinframework/spin-docs/blob/main/AGENTS.md

A collection of CLI commands for installing dependencies, building the project, serving the site, and running various checks and tests.

```bash
npm ci && npm ci --prefix ./spin-up-hub   # install
spin build                                # runs every [component.*.build] in spin.toml: indexes, JS bundle, Hub SPA
spin up -e PREVIEW_MODE=1                 # serve at http://localhost:3000, showing future-dated pages. Serves a snapshot of content/ and templates/ copied at startup, so restart it (or use spin watch / npm run spin) to see edits
spin watch -e PREVIEW_MODE=1              # same, rebuilding when content/ or templates/ change (extra args pass through to spin up)
npm run spin                              # nodemon alternative; regenerates indexes and restarts spin up, honors $PREVIEW_MODE

npm run build-index                       # content/ -> static/data.json (docs search)
npm run build-hub-index                   # content/api/hub/ -> static/hub-index-data.json (Hub search)
npm run bundle-scripts                    # parcel watch: static/js/src/main.js -> static/js/main.js
npm run styles                            # sass watch: static/sass/styles.scss -> static/css/styles.css

bart check --shortcodes shortcodes content/* && bart check --shortcodes shortcodes content/**/*   # front matter check (CI gate; see Front matter)
bart check --shortcodes shortcodes content/api/hub/*.md                                            # Hub entries (see Known issues 2)
npm run lint-markdown                     # markdownlint-cli2 over content/**/*.md
npx markdownlint-cli2 content/v4/install.md   # lint one file
npm test                                  # .build/check-broken-links.sh: boots the site, runs blc recursively from /javascript-components; follows only <a href>, so it covers v4, v3 and the blog, never v1 or v2 (see Known issues); takes minutes. Stop any spin up already on :3000 first, or the checker tests that server instead

cd spin-up-hub && npm run dev             # Vite dev server for the Hub; it fetches Hub data from VITE_API_HOST (see .env.development), so run the main site too. If it shows an empty Hub, see Known issues 7
```

--------------------------------

### Run Spin application locally

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/component-composition-spin-4-0.md

Use the spin up command with the --build flag to compile and start the application locally.

```bash
spin up --build
```

--------------------------------

### Markdown Body Content Example

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/contributing.md

An example of the Markdown content to be placed below the metadata block.

```markdown
This is the default HTTP trigger template for Rust. It installs by default with the [Spin install script](../../install#installing-spin).

This guide walks you through how to use it: [HTTP Components](../../rust-components#http-components)
```

--------------------------------

### Kinesis Trigger Configuration Example

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/plugin_spin_kinesis_trigger.md

Example TOML configuration for the [[trigger.kinesis]] section, showing all available options with sample values.

```toml
[[trigger.kinesis]]
component = "test"
stream_arn = "arn:aws:kinesis:us-east-1:1234567890:stream/TestStream"
batch_size = 1000
shard_idle_wait_millis = 250
detector_poll_millis = 30000
shard_iterator_type = "TRIM_HORIZON"
```

--------------------------------

### Install the latest version of the Spin OTel plugin

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/plugin_spin_otel.md

Updates the Spin plugin list and installs the latest stable release of the otel plugin.

```sh
spin plugins update
spin plugin install otel
```

--------------------------------

### Install the canary version of the Spin OTel plugin

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/plugin_spin_otel.md

Installs the canary release of the otel plugin from the GitHub releases URL. This version may be unstable.

```sh
spin plugins install --url https://github.com/fermyon/otel-plugin/releases/download/canary/otel.json
```

--------------------------------

### Install SQS Trigger Plugin

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/plugin_sqs_trigger.md

Use the spin plugins install command to add the SQS trigger plugin to your Spin environment.

```bash
spin plugins install --url https://github.com/spinframework/spin-trigger-sqs/releases/download/canary/trigger-sqs.json
```

--------------------------------

### Build and Run Spin App with SQLite Schema

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/sample_embedding_component.md

Command to build the Spin application and start it with the SQLite database schema file. Run this after cloning the repository. The schema file is located at dev/db_scheme.sql.

```bash
spin build && spin up --sqlite @dev/db_scheme.sql
```

--------------------------------

### Managing environment-specific plugins

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/announcing-spin-4-0.md

Use the -E flag to list or install plugins associated with a specific deployment environment.

```bash
$ spin plugins list -E <environment>
$ spin plugins install -E <environment>
```

--------------------------------

### Create a New Cron Application

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/plugin_spin_cron_trigger.md

Create a new application using the installed cron-rust template.

```bash
spin new -t cron-rust hello-cron --accept-defaults
```

--------------------------------

### Build wasmcp from source

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/mcp-with-wasmcp.md

Alternatively, build and install wasmcp directly from the source repository using cargo.

```shell
cargo install --git https://github.com/wasmcp/wasmcp
```

--------------------------------

### GitHub Component Tool Execution

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/deepfabric-spin.md

Commands to start the GitHub component tool with authentication and repository restrictions.

```bash
# Start with GitHub token for API access
SPIN_VARIABLE_GITHUB_TOKEN=ghp_xxx spin up

# Optionally restrict to specific repositories
SPIN_VARIABLE_ALLOWED_REPOS="myorg/repo1,myorg/repo2" spin up
```

--------------------------------

### Check Python version

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/template_http_python.md

Verify that the installed Python version meets the requirement of 3.10 or later.

```bash
python3 --version
```

--------------------------------

### Run a Spin app that exports telemetry data

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/plugin_spin_otel.md

Starts a Spin application with telemetry export using the OTel plugin. Any flags that work with 'spin up' also work with 'spin otel up'.

```sh
spin otel up
```

--------------------------------

### Middleware short-circuiting

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/announcing-spin-4-1.md

A Rust middleware example demonstrating how to short-circuit the chain by returning a response without calling the next handler.

```rust
#[http_service]
async fn require_token(request: Request) -> anyhow::Result<impl IntoResponse> {
    let authorized = request
        .headers()
        .get("authorization")
        .is_some_and(is_valid_token);

    if !authorized {
        return Ok(Response::new(401, "unauthorized"));
    }

    Ok(spin_sdk::http::next(request).await?)
}
```

--------------------------------

### Update Spin templates

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/announcing-spin-4-0.md

Run this command to update your installed Spin templates from the official repository.

```bash
spin templates install --git https://github.com/spinframework/spin --update
```

--------------------------------

### GET /items

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/architecture_crud_js_sqlite.md

Retrieves a list of all items from the SQLite database.

```APIDOC
## GET /items

### Description
Retrieves a list of all items.

### Method
GET

### Endpoint
/items

### Response
#### Success Response (200)
Returns a list of all items.

#### Response Example
[
  {
    "id": 1,
    "name": "item name",
    "active": true
  }
]
```

--------------------------------

### seekrit:secrets store interface in WIT

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/component_seekrit_secrets.md

Defines the store interface with get, get-all, list-names, and forget functions. get returns ok(none) for names not in scope, distinct from errors. list-names returns names without materializing values, suitable for health checks.

```wit
package seekrit:secrets@0.1.0;

interface store {
  variant error { not-configured(string), denied(string), unavailable(string), decrypt(string) }

  get:        func(name: string) -> result<option<string>, error>;
  get-all:    func()             -> result<list<tuple<string, string>>, error>;
  list-names: func()             -> result<list<string>, error>;
  forget:     func();
}

```

--------------------------------

### Implement MCP tools in Rust

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/mcp-with-wasmcp.md

Example implementation of the Guest trait for a Calculator tool, defining list_tools and call_tool methods in rust-tools/src/lib.rs.

```rust
/// rust-tools/src/lib.rs
impl Guest for Calculator {
    fn list_tools(
        _ctx: RequestCtx,
        _request: ListToolsRequest,
    ) -> Result<ListToolsResult, ErrorCode> {
        Ok(ListToolsResult {
            tools: vec![
                Tool {
                    name: "add".to_string(),
                    input_schema: r#"{
                        "type": "object",
                        "properties": {
                            "a": {"type": "number", "description": "First number"},
                            "b": {"type": "number", "description": "Second number"}
                        },
                        "required": ["a", "b"]
                    }"#
                    .to_string(),
                    options: None,
                },
                Tool {
                    name: "subtract".to_string(),
                    input_schema: r#"{
                        "type": "object",
                        "properties": {
                            "a": {"type": "number", "description": "Number to subtract from"},
                            "b": {"type": "number", "description": "Number to subtract"}
                        },
                        "required": ["a", "b"]
                    }"#
                    .to_string(),
                    options: None,
                },
            ],
            next_cursor: None,
            meta: None,
        })
    }

    fn call_tool(
        _ctx: RequestCtx,
        request: CallToolRequest,
    ) -> Result<Option<CallToolResult>, ErrorCode> {
        match request.name.as_str() {
            "add" => Ok(Some(execute_operation(&request.arguments, |a, b| a + b))),
            "subtract" => Ok(Some(execute_operation(&request.arguments, |a, b| a - b))),
            _ => Ok(None), // We don't handle this tool
        }
    }
}
```

--------------------------------

### Running the application

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/sample_seekrit_secrets_http_rust.md

Commands to build and run the application, followed by the expected output.

```bash
export SPIN_VARIABLE_SEEKRIT_TOKEN="skt_..."
spin build
spin up
curl localhost:3000
```

```text
in scope: DATABASE_URL, STRIPE_API_KEY
STRIPE_API_KEY: 32 bytes
```

--------------------------------

### Update and verify the Spin gh plugin

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/spin-gh-plugin-update.md

Commands to update the plugin index, upgrade the gh plugin, and verify the installation version.

```bash
# Update the plugin index
spin plugins update

# Upgrade (or Install) the gh plugin
spin plugins upgrade gh --yes

# Check installed version of Spin plugins
# For gh this should report 0.2.1
spin plugins list --installed
gh 0.2.1 [installed]
```

--------------------------------

### GitHub Actions workflow steps for SBOM generation, scanning, and attachment

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/spin-gh-plugin-update.md

The generated workflow installs trivy and oras, generates an SBOM with trivy fs, scans it with trivy sbom using --exit-code 1 --severity HIGH,CRITICAL (failing on HIGH or CRITICAL vulnerabilities), and attaches the SBOM via oras attach. The steps are repeated for each app (app-one and app-two).

```yaml
name: "CI"
# ...
jobs:
  spin:
    # ...
    steps:
      - name: Install trivy
        uses: aquasecurity/setup-trivy@e07451d2e059ed86c2870430ea286b3a9e0bf241
      - name: Install ORAS
        uses: oras-project/setup-oras@v1
        # ...
      - name: Generate SBOM for app-one
        working-directory: ./app-one
        run: |
          trivy fs --format spdx-json -o sbom.spdx.json .
      - name: Scan app-one SBOM for Critical Vulnerabilities
        working-directory: ./app-one
        run: |
          trivy sbom --exit-code 1 --severity HIGH,CRITICAL sbom.spdx.json
      - name: Authenticate against OCI registry for app-one
        # ...
      - name: Push OCI Artifact for app-one
        # ...
      - name: Sign OCI Artifact for app-one
        # ...
      - name: Attach app-one SBOM via ORAS
        working-directory: ./app-one
        run: |
          oras attach --artifact-type application/spdx+json ghcr.io/thorstenhans/tmp-app-one:latest sbom.spdx.json

      - name: Generate SBOM for app-two
        working-directory: ./app-two
        run: |
          trivy fs --format spdx-json -o sbom.spdx.json .
      - name: Scan app-two SBOM for Critical Vulnerabilities
        working-directory: ./app-two
        run: |
          trivy sbom --exit-code 1 --severity HIGH,CRITICAL sbom.spdx.json
      - name: Authenticate against OCI registry for app-two
        # ...
      - name: Push OCI Artifact for app-two
        # ...
      - name: Sign OCI Artifact for app-two
        # ...
      - name: Attach app-two SBOM via ORAS
        working-directory: ./app-two
        run: |
          oras attach --artifact-type application/spdx+json ghcr.io/thorstenhans/tmp-app-two:latest sbom.spdx.json
```

--------------------------------

### WASI 0.3.0 world definition

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/announcing-spin-4-1.md

Example of the spin:up@4.1.0 world definition supporting both WASIp3 and WASIp2 interfaces.

```wit
package spin:up@4.1.0;

world http-trigger {
  include platform;
  export wasi:http/handler@0.3.0;
}

world platform {
  include wasi:cli/imports@0.2.6;
  include wasi:cli/imports@0.3.0-rc-2026-03-15;
  include wasi:cli/imports@0.3.0;
  import wasi:http/outgoing-handler@0.2.6;
  import wasi:http/client@0.3.0-rc-2026-03-15;
  import wasi:http/client@0.3.0;
  // ...
}
```

--------------------------------

### Initialize and create GitHub repository

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/spin-gh-plugin-update.md

Commands to initialize a local Git repository and create a corresponding public repository on GitHub.

```bash
# Init the Git repository
git init

# Create a new GitHub repository
gh repo create tmp--the-new-spin-gh \
  -d "Exploring latest features of spin gh" \
  --public \
  --source .
```

--------------------------------

### Front Matter TOML Configuration

Source: https://github.com/spinframework/spin-docs/blob/main/AGENTS.md

Example of the required TOML-style front matter for markdown pages. Ensure all values are quoted and the block is terminated by a --- separator.

```toml
title = "Page Title"
template = "main"
date = "2023-11-04T00:00:01Z"
enable_shortcodes = true
[extra]
url = "https://github.com/spinframework/spin-docs/blob/main/content/v4/<file>.md"
keywords = "term1 term2"

---
```

--------------------------------

### Configure outbound connection limits in runtime config

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/announcing-spin-4-1.md

Example runtime configuration for Spin 4.1 that sets global and per-protocol connection limits. The [outbound_http] max_concurrent_requests option is deprecated in favor of max_connections.

```toml
[outbound_networking]
max_total_connections = 500    # global ceiling across every outbound kind
max_socket_connections = 100   # raw wasi-sockets specifically

[outbound_http]
max_connections = 200

[outbound_pg]
max_connections = 50

[outbound_redis]
max_connections = 50
```

--------------------------------

### Targeting a deployment environment with spin new

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/announcing-spin-4-0.md

Use the -E flag to fetch environment-specific templates and plugins on demand.

```bash
$ spin new -E <environment>
```

--------------------------------

### Build and run the Spin application

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/sample_http_auth_middleware.md

Build and execute the Spin application with the necessary GitHub OAuth environment variables.

```bash
# Build and run the example
spin up --build -f example -e CLIENT_ID=<YOUR_GITHUB_APP_CLIENT_ID> -e CLIENT_SECRET=<YOUR_GITHUB_APP_CLIENT_SECRET>

# Open http://127.0.0.1:3000/login in a browser
```

--------------------------------

### Deploy application to production

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/sample_weather_data_aggregator.md

Commands to generate an API token, deploy the application using Spin, and verify the deployment with a POST request.

```sh
export SPIN_VARIABLE_API_TOKEN=$(tr -dc A-Za-z0-9 </dev/urandom | head -c 16)
spin deploy --build \
--variable api_token=$E:SPIN_VARIABLE_API_TOKEN \
--variable kv_explorer_user=$E:SPIN_VARIABLE_KV_EXPLORER_USER \
--variable kv_explorer_password=$E:SPIN_VARIABLE_KV_EXPLORER_PASSWORD
curl -X POST -d @api/examples/mixed.json 'https://weather.fermyon.app/api/v1?token='$SPIN_VARIABLE_API_TOKEN
```

--------------------------------

### Commit and push demo applications

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/spin-gh-plugin-update.md

Commands to add a README, commit the project files, and push the repository to GitHub.

```bash
# Create a simple README
echo '# Exploring latest features of spin gh' >> README.md

# Use git to do git things
git add .
git commit -sm 'chore: Add two sample applications'
git push -u origin main
```

--------------------------------

### Build Spin Application

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/sample_ollama.md

Command to build the Spin application.

```bash
spin build
```

--------------------------------

### Create and build a new Spin Nuxt app

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/template_nuxt.md

Commands to initialize a new Spin application using the Nuxt template and build the project.

```bash
$ spin new my-nuxt -t Nuxt
$ cd my-nuxt-app
$ spin build
```

--------------------------------

### Configure key-value store in spin.toml

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/announcing-spin-3-6.md

Enable key-value store access in your Spin configuration file.

```toml
key_value_stores = ["default"]
```

--------------------------------

### GET /items/:id

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/architecture_crud_js_sqlite.md

Retrieves a single item using its identifier.

```APIDOC
## GET /items/:id

### Description
Retrieves an item using its identifier.

### Method
GET

### Endpoint
/items/:id

### Parameters
#### Path Parameters
- **id** (string) - Required - The identifier of the item to retrieve.

### Response
#### Success Response (200)
Returns the item with the specified identifier.

#### Response Example
{
  "id": 1,
  "name": "item name",
  "active": true
}
```

--------------------------------

### Terminate the Spin OTel dashboards

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/plugin_spin_otel.md

Stops and cleans up the dashboards started by the OTel plugin.

```sh
spin otel cleanup
```

--------------------------------

### Build and run with Spin

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/sample_11ty.md

Commands to build and execute the application within the Spin environment.

```bash
spin build
spin up
```

--------------------------------

### Run Spin with build profiles

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/announcing-spin-4-0.md

Execute the application using the default build or a specific profile using the --profile flag.

```bash
# Production: every component uses its default build.
$ spin up

# Debug: every component that defines `debug` uses it; others fall back.
$ spin up --profile debug
```

--------------------------------

### Run the MCP server with Spin

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/mcp-with-wasmcp.md

Execute the composed server component using the Spin runtime.

```shell
spin up --from server.wasm
```

--------------------------------

### Add a headless Wasm component

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/component-composition-spin-4-0.md

Add the classifier component to the application using the installed headless-rust template.

```bash
spin add -t headless-rust classifier -a
```

--------------------------------

### Verify project directory structure

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/component-composition-spin-4-0.md

Check the contents of the composition-demo folder to ensure the project was scaffolded correctly.

```bash
.
├── Cargo.toml
├── classifier
│   ├── Cargo.toml
│   ├── src
│   │   └── lib.rs
│   └── wit
│       └── world.wit
├── spin.toml
└── src
    └── lib.rs
```

--------------------------------

### Deploy Spin Application

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/sample_ollama.md

Command to deploy the Spin application.

```bash
spin deploy
```

--------------------------------

### Create and run a Zola Spin application

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/template_zola_ssg.md

Commands to initialize a new Spin application using the zola-ssg template, navigate to the directory, and build/run the project.

```bash
$ spin new zola-ssg my-blog
$ cd my-blog
$ spin build --up
```

--------------------------------

### Run the composed server with Spin

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/mcp-with-wasmcp.md

Execute the polyglot MCP server using the Spin runtime.

```shell
spin up --from polyglot.wasm
```

--------------------------------

### Configure dependency capabilities

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/announcing-spin-4-2.md

The interactive prompt asks to grant capabilities to the dependency, allowing you to inherit all, none, or choose individually.

```text
This dependency uses the following capabilities: allowed_outbound_hosts, environment
If inherited, it gets the same access to them as component 'spin-deps-test'.
Which capabilities should the dependency inherit?:
> Inherit all of them
  Inherit none of them (the dependency will fail if it tries to use them)
  Choose individually
```

--------------------------------

### Build and Run Kinesis Application

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/plugin_spin_kinesis_trigger.md

Builds and runs the newly created Kinesis application.

```bash
cd hello-kinesis
spin build --up
```

--------------------------------

### Go component build configuration

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/announcing-spin-4-0.md

Configuration for building a Spin Go component using the componentize-go tool.

```toml
[component.hello-go.build]
command = "go tool componentize-go build"
```

--------------------------------

### Async Content-Length Fetcher

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/announcing-spin-3-5.md

An asynchronous helper function that performs an HTTP GET request and parses the Content-Length header from the response.

```rust
async fn get_content_length(url: &str) -> anyhow::Result<Option<u64>> {
    let request = Request::get(url).body(EmptyBody::new())?;
    let response = send(request).await?;
    let cl_header = response.headers().get("content-length");
    let cl = cl_header.and_then(|hval| hval.to_str().ok()).and_then(|hval| hval.parse().ok());
    Ok(cl)
}
```

--------------------------------

### Run component from OCI registry with spin up

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/mcp-with-wasmcp.md

Automatically resolves and runs a component directly from an OCI registry.

```shell
spin up --from ghcr.io/mygithub/rust-tools:0.1.0
```

--------------------------------

### Scaffold demo applications

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/spin-gh-plugin-update.md

Commands to create a project directory and scaffold two independent Spin applications using Rust and TypeScript templates.

```bash
# Create a new top-level folder
mkdir the-new-spin-gh
cd the-new-spin-gh

# Scaffolding the 1st Spin app
spin new -t http-rust --no-vcs -a app-one

# Scaffolding the 2nd Spin app
spin new -t http-ts --no-vcs -a app-two
```

--------------------------------

### Middleware request header modification

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/announcing-spin-4-1.md

A Rust middleware example that fetches data and adds a header to the request before calling the next handler.

```rust
#[http_service]
async fn add_animal_fact_header(
    request: Request,
) -> Result<Response, spin_sdk::wasip3::http::types::ErrorCode> {
    let animal_fact_response =
        spin_sdk::http::get("https://random-data-api.fermyon.app/animals/json").await?;
    let animal_fact_json = animal_fact_response.into_body().bytes().await?;
    let animal_fact: AnimalFact = serde_json::from_slice(&animal_fact_json).unwrap();

    let (mut parts, body) = request.into_parts();
    parts.headers.append(
        "animal-fact",
        HeaderValue::from_str(&animal_fact.fact).unwrap(),
    );
    let request = Request::from_parts(parts, body);

    spin_sdk::http::next(request).await
}
```

--------------------------------

### Configure OTel context and environment

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/announcing-spin-3-6.md

Set up the tracer and tracing layer within the http_component handler to bridge tracing with OpenTelemetry.

```rust
#[http_component]
fn handle_request(_req: Request) -> anyhow::Result<impl IntoResponse> {
    // Set up a tracer backed by the WASI span processor
    let wasi_processor = WasiSpanProcessor::new();
    let provider = SdkTracerProvider::builder()
        .with_span_processor(wasi_processor)
        .build();
    let tracer = provider.tracer("tracing-spin");

    // Bridge the tracing crate to OpenTelemetry
    let tracing_layer = tracing_opentelemetry::layer().with_tracer(tracer);
    registry().with(tracing_layer).try_init().unwrap();

    // Propagate the trace context from the Spin host so your
    // spans appear as children of the Spin-level request span
    let wasi_propagator = TraceContextPropagator::new();
    let _guard = wasi_propagator.extract(&Context::current()).attach();

    main_operation(); // see below

    Ok(Response::builder()
        .status(200)
        .header("content-type", "text/plain")
        .body("Hello, Spin!")
        .build())
}
```

--------------------------------

### Consume image manipulation dependency in TypeScript

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/announcing-spin-3.md

Example of importing and using functions from an image manipulation library within a TypeScript component.

```javascript
import { grayscale, sepia } from "component:image-manipulation-lib/image-manipulation"

// ...

switch (transform) {
    case "grayscale":
        transformed = grayscale(new Uint8Array(body), quality);
        break;
    case "sepia":
        transformed = sepia(new Uint8Array(body), quality);
        break;
    default:
        throw new Error("Unknown image transform");
}
```

--------------------------------

### Initialize a new Python tool component

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/mcp-with-wasmcp.md

Use the wasmcp CLI to scaffold a new Python project for tool development.

```shell
wasmcp new python-tools --language python
cd python-tools
make
```

--------------------------------

### seekrit:secrets interface

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/component_seekrit_secrets.md

WIT interface definition for the seekrit secrets component, including the error type and the functions get, get-all, list-names, and forget.

```APIDOC
## seekrit:secrets interface

### Description
WIT interface for the seekrit secrets component. It provides functions to retrieve secrets, list secret names, and forget cached values.

### Interface

```wit
package seekrit:secrets@0.1.0;

interface store {
  variant error { not-configured(string), denied(string), unavailable(string), decrypt(string) }

  get:        func(name: string) -> result<option<string>, error>;
  get-all:    func()             -> result<list<tuple<string, string>>, error>;
  list-names: func()             -> result<list<string>, error>;
  forget:     func();
}
```
```

--------------------------------

### Select individual capabilities

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/announcing-spin-4-2.md

Selecting 'Choose individually' allows you to toggle specific capabilities like 'allowed_outbound_hosts' or 'environment' for the dependency.

```text
Select the capabilities to inherit:
> [x] allowed_outbound_hosts
  [ ] environment
```

--------------------------------

### Scaffold a new Spin application

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/announcing-spin-3-6.md

Initialize a new Rust Spin application using the http-rust template.

```bash
spin new wasi-otel-demo -t http-rust --accept-defaults
```

--------------------------------

### Configure MCP server with spin.toml

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/mcp-with-wasmcp.md

Define the application manifest for the MCP server to provide runtime configuration.

```toml
# rust-tools/spin.toml
spin_manifest_version = 2

[application]
name = "mcp"
version = "0.1.0"
authors = ["You <you@gmail.com>"]
description = "My MCP server"

[[trigger.http]]
route = "/mcp"
component = "mcp"

[component.mcp]
source = "server.wasm"
allowed_outbound_hosts = [] # Update for outbound HTTP
```

--------------------------------

### Clone the Spin Docs Repository

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/contributing.md

Commands to navigate to the home directory, clone your fork of the spin-docs repository, and enter the project directory.

```bash
$ cd ~
$ git clone git@github.com:yourusername/spin-docs.git
$ cd spin-docs
```

--------------------------------

### Show help for spin otel up

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/plugin_spin_otel.md

Displays the help information for the 'spin otel up' command, showing all available flags.

```sh
spin otel up -- --help
```

--------------------------------

### Add dependencies for composition-demo

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/component-composition-spin-4-0.md

Use cargo to add the required serde and serde_json dependencies to the project.

```bash
cargo add serde -F derive
cardo add serde_json
```

--------------------------------

### Scaffold a WASIp3 Spin application

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/announcing-spin-3-5.md

Use the http-rust-wasip3-unstable template to create a new application named hello-p3. This creates a directory with a basic p3 application using the new Rust SDK and the wasip3-unstable executor type.

```console
$ spin new hello-p3 -t http-rust-wasip3-unstable
```

--------------------------------

### Initialize TypeScript component and add dependency

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/announcing-spin-3.md

Commands to create a new Spin TypeScript application and add the previously published Rust component as a dependency.

```console
# create a new Spin application based on the TypeScript template
$ spin new -t http-ts image-manipulation-http-api

# add a dependency to the image manipulation component we pushed to the registry
$ spin deps add --registry fermyon.com \
		fermyon-experimental:image-manipulation-lib@6.0.0
```

--------------------------------

### Login and push to OCI registry with spin registry

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/mcp-with-wasmcp.md

Authenticates with an OCI registry and pushes a component using the spin registry command.

```shell
echo $GHCR_PAT | spin registry login --username mygithub --password-stdin ghcr.io
spin registry push ghcr.io/mygithub/rust-tools:0.1.0
```

--------------------------------

### Enabling shell completions

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/announcing-spin-4-0.md

Add the completion command to your shell startup file. Change the COMPLETE variable to zsh for zsh support.

```bash
source <(COMPLETE=bash spin maintenance generate-completions)
```

--------------------------------

### Enable keyless signing with spin gh create-action

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/spin-gh-plugin-update.md

Use the --sign flag to enable keyless OCI artifact signing. This command requires --push-oci-artifacts to be present.

```bash
spin gh create-action --push-oci-artifacts --sign --overwrite
```

--------------------------------

### Create GitHub Action with OCI support

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/spin-gh-plugin-update.md

Use the spin gh create-action command with the --push-oci-artifacts flag to initiate the interactive TUI for configuring OCI registry publication.

```bash
spin gh create-action --ci main \
  --name "Demo Apps CI" \
  --push-oci-artifacts \
  --overwrite
```

--------------------------------

### POST /mock/pull

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/deepfabric-spin.md

Pulls Tool definitions from a real MCP server endpoint and loads them into Spin for mock execution. The response includes the number of loaded tools and their names.

```APIDOC
## POST /mock/pull

### Description
Pulls Tool definitions from a real MCP server endpoint and loads them into Spin for mock execution. The response includes the number of loaded tools and their names.

### Method
POST

### Endpoint
/mock/pull

### Parameters
#### Request Body
- **url** (string) - Required - The URL of the MCP server endpoint.

### Request Example
{
  "url": "http://localhost:8080/mcp"
}

### Response
#### Success Response (200)
- **loaded** (integer) - Number of tools loaded.
- **tools** (array of strings) - Names of the loaded tools.

#### Response Example
{
  "loaded": 12,
  "tools": ["get_weather", "search_files", "run_query"]
}
```

--------------------------------

### Generate GitHub Actions workflow with SBOM flag

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/spin-gh-plugin-update.md

Run spin gh create-action with --push-oci-artifacts, --sign, --sbom, and --overwrite to generate a workflow that includes SBOM generation and scanning. The --sbom flag requires --push-oci-artifacts.

```bash
spin gh create-action --push-oci-artifacts --sign --sbom --overwrite
```

--------------------------------

### Scaffold a new Rust MCP tool

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/mcp-with-wasmcp.md

Initialize a new Rust project for an MCP tool component.

```shell
wasmcp new rust-tools --language rust
```

--------------------------------

### Add Mock Fixtures

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/deepfabric-spin.md

Define argument-specific responses using fixtures. Fixtures are matched by specificity.

```bash
# Add a fixture for specific arguments
curl -X POST http://localhost:3000/mock/add-fixture \
  -H "Content-Type: application/json" \
  -d '{
    "name": "get_weather",
    "match": {"location": "Seattle"},
    "response": {"temperature": 55, "conditions": "Rainy", "location": "Seattle"}
  }'

# Fixtures can match multiple arguments
curl -X POST http://localhost:3000/mock/add-fixture \
  -H "Content-Type: application/json" \
  -d '{
    "name": "search_files",
    "match": {"directory": "/src", "pattern": "*.py"},
    "response": {"files": ["main.py", "utils.py", "config.py"], "count": 3}
  }'
```

--------------------------------

### Add KV explorer to application

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/template_kv_explorer.md

Use the spin add command to incorporate the KV explorer component into your application.

```sh
spin add kv-explorer -t kv-explorer
```

--------------------------------

### Login to Fermyon Cloud

Source: https://github.com/spinframework/spin-docs/blob/main/content/api/hub/sample_ollama.md

Command to authenticate with Fermyon Cloud.

```bash
spin login
```

--------------------------------

### Compose multiple components into a single server

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/mcp-with-wasmcp.md

Combine the Python and Rust component binaries into a single polyglot.wasm file.

```shell
cd ..
wasmcp compose server ./python-tools/python-tools.wasm ./rust-tools/target/wasm32-wasip2/release/rust_tools.wasm -o polyglot.wasm
```

--------------------------------

### Spin targets CLI commands

Source: https://github.com/spinframework/spin-docs/blob/main/content/blog/announcing-spin-4-1.md

Commands to list available target environments and refresh the catalogue.

```console
$ spin targets list      # list known target environments
$ spin targets update    # refresh the list from the master catalogue
```
Tokens:
Raw