sbox-api-mcp 1.0.0 → 1.2.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "sbox-api",
-  "description": "S&box game engine API documentation lookup for Claude Code. Search types, methods, properties, and documentation across the entire S&box API.",
+  "description": "S&box game engine MCP for Claude Code. Search API types, methods, and properties. Browse wiki documentation (guides, tutorials, concepts). Find Workshop community assets (models, sounds, maps, and more).",
   "author": {
     "name": "sofianebel"
   }

package/README.md

@@ -1,6 +1,6 @@
 # sbox-api-mcp
 
-MCP server for [S&box](https://sbox.game) game engine API documentation lookup. Indexes **1800+ types**, **15,000+ members**, and **8,000+ documentation entries** from the S&box API, providing fast fuzzy search directly from Claude Code.
+MCP server for [S&box](https://sbox.game) game engine — API reference, wiki documentation, and Workshop assets. Indexes **1800+ types**, **15,000+ members**, and **8,000+ documentation entries** from the S&box API, plus **200+ wiki pages** (guides, tutorials, concepts) and community Workshop assets, all searchable directly from Claude Code.
 
 ## Installation
 
@@ -26,12 +26,19 @@ npx sbox-api-mcp
 
 | Tool | Description | Example |
 |------|-------------|---------|
+| **API Reference** | | |
 | `search_types` | Fuzzy search types (classes, structs, enums, interfaces) | `search_types({ query: "GameObject" })` |
 | `get_type` | Full details of a specific type (methods, properties, fields) | `get_type({ name: "Sandbox.GameObject" })` |
 | `search_members` | Search methods/properties across all types | `search_members({ query: "Position", kind: "property" })` |
 | `list_namespaces` | List all API namespaces with type counts | `list_namespaces({ filter: "Audio" })` |
 | `search_docs` | Full-text search in documentation summaries | `search_docs({ query: "play sound" })` |
 | `update_api_source` | Update API data URL when S&box releases a new version | `update_api_source({ url: "https://cdn.sbox.game/releases/..." })` |
+| **Wiki Documentation** | | |
+| `search_wiki` | Search s&box wiki pages (guides, tutorials, concepts) | `search_wiki({ query: "networking" })` |
+| `get_wiki_page` | Get the full content of a wiki page as markdown | `get_wiki_page({ path: "scene/components" })` |
+| **Workshop (UGC)** | | |
+| `search_packages` | Search community Workshop assets (models, sounds, maps, etc.) | `search_packages({ query: "zombie" })` |
+| `get_package` | Get details of a specific Workshop package | `get_package({ ident: "facepunch.zombiemale" })` |
 
 ## Configuration
 
@@ -53,9 +60,11 @@ The URL format is: `https://cdn.sbox.game/releases/YYYY-MM-DD-HH-MM-SS.zip.json`
 
 ## How It Works
 
-On first startup, the server downloads the S&box API JSON (~9 MB) and caches it locally in `~/.sbox-api-mcp/`. Subsequent startups use an ETag check to skip re-downloading if the data hasn't changed.
+**API Reference:** On first startup, the server downloads the S&box API JSON (~9 MB) and caches it locally in `~/.sbox-api-mcp/`. Subsequent startups use an ETag check to skip re-downloading if the data hasn't changed. The API data is indexed in-memory using [Fuse.js](https://www.fusejs.io/) for fast fuzzy search across type names, member names, and documentation summaries.
 
-The API data is indexed in-memory using [Fuse.js](https://www.fusejs.io/) for fast fuzzy search across type names, member names, and documentation summaries.
+**Wiki Documentation:** Leverages S&box's LLM-optimized endpoints (`llms.txt` index + `.md` raw markdown pages). The wiki index is fetched on first use and cached in-memory for 1 hour. Individual pages are fetched live from `sbox.game/dev/doc/` as raw markdown.
+
+**Workshop (UGC):** Queries the Facepunch services API live for community-made assets.
 
 ## License
 

package/dist/data/ugc-client.d.ts

@@ -0,0 +1,53 @@
+export declare const PACKAGE_TYPES: readonly ["model", "sound", "material", "map", "game", "clothing", "library", "vsnd", "prefab", "shader"];
+export type PackageType = (typeof PACKAGE_TYPES)[number];
+export interface PackageOrg {
+    Ident: string;
+    Title: string;
+    Description?: string;
+    Thumb?: string;
+    Twitter?: string;
+    WebUrl?: string;
+    Discord?: string;
+}
+export interface UgcPackage {
+    Org: PackageOrg;
+    Ident: string;
+    FullIdent: string;
+    Title: string;
+    Summary?: string;
+    Thumb?: string;
+    ThumbWide?: string;
+    ThumbTall?: string;
+    VideoThumb?: string;
+    TypeName: string;
+    Updated: string;
+    Created: string;
+    UsageStats?: Record<string, unknown>;
+    Tags?: string[];
+    Favourited?: number;
+    VotesUp?: number;
+    Collections?: number;
+    Referenced?: number;
+    Public?: boolean;
+}
+export interface SearchPackagesResponse {
+    Packages: UgcPackage[];
+    TotalCount: number;
+    Facets: unknown[];
+    Tags?: Record<string, number>;
+    Orders?: Array<{
+        Name: string;
+        Title: string;
+        Icon: string;
+    }>;
+}
+export interface SearchPackagesParams {
+    query: string;
+    type?: PackageType;
+    category?: string;
+    tag?: string;
+    order?: string;
+    take?: number;
+    skip?: number;
+}
+export declare function searchPackages(params: SearchPackagesParams): Promise<SearchPackagesResponse>;

package/dist/data/ugc-client.js

@@ -0,0 +1,26 @@
+const UGC_API_BASE = 'https://services.facepunch.com/sbox/package';
+export const PACKAGE_TYPES = [
+    'model', 'sound', 'material', 'map', 'game',
+    'clothing', 'library', 'vsnd', 'prefab', 'shader',
+];
+export async function searchPackages(params) {
+    const url = new URL(`${UGC_API_BASE}/find`);
+    url.searchParams.set('q', params.query);
+    if (params.type)
+        url.searchParams.set('type', params.type);
+    if (params.category)
+        url.searchParams.set('category', params.category);
+    if (params.tag)
+        url.searchParams.set('tag', params.tag);
+    if (params.order)
+        url.searchParams.set('order', params.order);
+    if (params.take)
+        url.searchParams.set('take', String(params.take));
+    if (params.skip)
+        url.searchParams.set('skip', String(params.skip));
+    const res = await fetch(url.toString());
+    if (!res.ok) {
+        throw new Error(`UGC API error: ${res.status} ${res.statusText}`);
+    }
+    return res.json();
+}

package/dist/data/wiki-client.d.ts

@@ -0,0 +1,11 @@
+export interface WikiEntry {
+    title: string;
+    path: string;
+    section: string;
+}
+export declare function searchWikiIndex(query: string, section?: string, limit?: number): Promise<WikiEntry[]>;
+export declare function getWikiSections(): Promise<Map<string, number>>;
+export declare function fetchWikiPage(path: string): Promise<{
+    content: string;
+    url: string;
+}>;

package/dist/data/wiki-client.js

@@ -0,0 +1,111 @@
+import Fuse from 'fuse.js';
+const LLMS_TXT_URL = 'https://sbox.game/llms.txt';
+const WIKI_BASE_URL = 'https://sbox.game';
+const CACHE_TTL = 60 * 60 * 1000; // 1 hour
+const SECTION_LABELS = {
+    'getting-started': 'Getting Started',
+    'scene': 'Scene',
+    'code': 'Code',
+    'editor': 'Editor',
+    'assets': 'Assets',
+    'graphics': 'Graphics',
+    'ui': 'UI',
+    'gameplay': 'Gameplay',
+    'networking': 'Networking',
+    'services': 'Services',
+};
+let cache = null;
+function parseLlmsTxt(raw) {
+    const entries = [];
+    const linkPattern = /^-\s+\[(.+?)]\((.+?)\)/;
+    for (const line of raw.split('\n')) {
+        const match = line.match(linkPattern);
+        if (!match)
+            continue;
+        const [, title, path] = match;
+        if (!path.startsWith('/dev/doc/'))
+            continue;
+        // Extract section from first path segment after /dev/doc/
+        const segments = path.replace('/dev/doc/', '').replace(/\.md$/, '').split('/');
+        const sectionSlug = segments[0];
+        const section = SECTION_LABELS[sectionSlug] ?? sectionSlug;
+        entries.push({ title, path, section });
+    }
+    return entries;
+}
+function buildWikiFuse(entries) {
+    return new Fuse(entries, {
+        keys: [
+            { name: 'title', weight: 3 },
+            { name: 'path', weight: 1 },
+            { name: 'section', weight: 0.5 },
+        ],
+        threshold: 0.4,
+        includeScore: true,
+        minMatchCharLength: 2,
+    });
+}
+function buildSectionCounts(entries) {
+    const sections = new Map();
+    for (const entry of entries) {
+        sections.set(entry.section, (sections.get(entry.section) ?? 0) + 1);
+    }
+    return sections;
+}
+async function fetchLlmsTxt() {
+    const res = await fetch(LLMS_TXT_URL);
+    if (!res.ok) {
+        throw new Error(`Failed to fetch llms.txt: ${res.status} ${res.statusText}`);
+    }
+    return res.text();
+}
+async function getOrBuildIndex() {
+    if (cache && Date.now() < cache.expiry) {
+        return cache;
+    }
+    console.error('[sbox-api] Fetching wiki index from llms.txt...');
+    const raw = await fetchLlmsTxt();
+    const entries = parseLlmsTxt(raw);
+    const fuse = buildWikiFuse(entries);
+    const sections = buildSectionCounts(entries);
+    console.error(`[sbox-api] Wiki index: ${entries.length} pages, ${sections.size} sections`);
+    cache = { entries, fuse, sections, expiry: Date.now() + CACHE_TTL };
+    return cache;
+}
+export async function searchWikiIndex(query, section, limit = 10) {
+    const index = await getOrBuildIndex();
+    if (!query) {
+        let entries = index.entries;
+        if (section) {
+            entries = entries.filter(e => e.section.toLowerCase() === section.toLowerCase());
+        }
+        return entries.slice(0, limit);
+    }
+    const results = index.fuse.search(query, { limit: limit * 2 });
+    let entries = results.map(r => r.item);
+    if (section) {
+        entries = entries.filter(e => e.section.toLowerCase() === section.toLowerCase());
+    }
+    return entries.slice(0, limit);
+}
+export async function getWikiSections() {
+    const index = await getOrBuildIndex();
+    return index.sections;
+}
+export async function fetchWikiPage(path) {
+    // Normalize path: accept various formats
+    let normalized = path.trim();
+    // Strip leading /dev/doc/ if present
+    normalized = normalized.replace(/^\/dev\/doc\//, '');
+    // Strip leading slash
+    normalized = normalized.replace(/^\//, '');
+    // Strip trailing .md
+    normalized = normalized.replace(/\.md$/, '');
+    const url = `${WIKI_BASE_URL}/dev/doc/${normalized}.md`;
+    const res = await fetch(url);
+    if (!res.ok) {
+        throw new Error(`Wiki page not found: ${res.status} ${res.statusText} (${url})`);
+    }
+    const content = await res.text();
+    return { content, url };
+}

package/dist/index.js

@@ -9,6 +9,10 @@ import { registerSearchMembers } from './tools/search-members.js';
 import { registerListNamespaces } from './tools/list-namespaces.js';
 import { registerSearchDocs } from './tools/search-docs.js';
 import { registerUpdateSource } from './tools/update-source.js';
+import { registerSearchPackages } from './tools/search-packages.js';
+import { registerGetPackage } from './tools/get-package.js';
+import { registerSearchWiki } from './tools/search-wiki.js';
+import { registerGetWikiPage } from './tools/get-wiki-page.js';
 async function main() {
     console.error('[sbox-api] Starting S&box API MCP Server...');
     // Load API data
@@ -26,6 +30,12 @@ async function main() {
     registerListNamespaces(server, indexes);
     registerSearchDocs(server, indexes);
     registerUpdateSource(server, indexes);
+    // UGC Workshop tools (no indexes needed - live API)
+    registerSearchPackages(server);
+    registerGetPackage(server);
+    // Wiki documentation tools (live API, in-memory cached index)
+    registerSearchWiki(server);
+    registerGetWikiPage(server);
     // Connect via stdio
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/dist/tools/get-package.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerGetPackage(server: McpServer): void;

package/dist/tools/get-package.js

@@ -0,0 +1,87 @@
+import { z } from 'zod';
+import { searchPackages } from '../data/ugc-client.js';
+function formatPackageDetails(pkg) {
+    const sections = [];
+    sections.push(`# ${pkg.Title}`);
+    sections.push(`**Identifier:** \`${pkg.FullIdent}\``);
+    sections.push(`**Type:** ${pkg.TypeName}`);
+    if (pkg.Summary)
+        sections.push(`**Summary:** ${pkg.Summary}`);
+    sections.push(`**Author:** ${pkg.Org.Title} (${pkg.Org.Ident})`);
+    sections.push('');
+    sections.push('## Stats');
+    if (pkg.VotesUp)
+        sections.push(`- Votes: ${pkg.VotesUp}`);
+    if (pkg.Favourited)
+        sections.push(`- Favourited: ${pkg.Favourited}`);
+    if (pkg.Collections)
+        sections.push(`- In collections: ${pkg.Collections}`);
+    if (pkg.Referenced)
+        sections.push(`- Referenced by: ${pkg.Referenced}`);
+    sections.push('');
+    sections.push('## Dates');
+    sections.push(`- Created: ${pkg.Created}`);
+    sections.push(`- Updated: ${pkg.Updated}`);
+    if (pkg.Tags?.length) {
+        sections.push('');
+        sections.push(`## Tags\n${pkg.Tags.join(', ')}`);
+    }
+    if (pkg.Thumb) {
+        sections.push('');
+        sections.push(`## Thumbnail\n${pkg.Thumb}`);
+    }
+    sections.push('');
+    sections.push(`## Usage\nUse \`${pkg.FullIdent}\` in your S&box project to reference this package.`);
+    sections.push(`Workshop page: https://sbox.game/${pkg.Org.Ident}/${pkg.Ident}`);
+    return sections.join('\n');
+}
+export function registerGetPackage(server) {
+    server.registerTool('get_package', {
+        title: 'Get S&box Package Details',
+        description: 'Get detailed information about a specific S&box Workshop package by its identifier (e.g., "facepunch.zombiemale"). Returns full metadata including stats, tags, author info, and usage instructions.',
+        inputSchema: {
+            ident: z
+                .string()
+                .describe("Package identifier in 'org.name' format (e.g., 'facepunch.zombiemale', 'fpopium.chair_01')"),
+        },
+    }, async ({ ident }) => {
+        try {
+            // The API doesn't have a direct get-by-id endpoint,
+            // so we search with the exact ident and filter
+            const parts = ident.split('.');
+            const searchQuery = parts.length > 1 ? parts[1] : ident;
+            const response = await searchPackages({ query: searchQuery, take: 20 });
+            const pkg = response.Packages.find(p => p.FullIdent.toLowerCase() === ident.toLowerCase());
+            if (!pkg) {
+                // Try broader search
+                const broader = await searchPackages({ query: ident, take: 20 });
+                const found = broader.Packages.find(p => p.FullIdent.toLowerCase() === ident.toLowerCase());
+                if (!found) {
+                    const suggestions = response.Packages.slice(0, 5)
+                        .map(p => `  - ${p.FullIdent} ("${p.Title}")`)
+                        .join('\n');
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: `Package "${ident}" not found.\n\nSimilar packages:\n${suggestions}`,
+                            }],
+                    };
+                }
+                return {
+                    content: [{ type: 'text', text: formatPackageDetails(found) }],
+                };
+            }
+            return {
+                content: [{ type: 'text', text: formatPackageDetails(pkg) }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Error fetching package: ${err instanceof Error ? err.message : String(err)}`,
+                    }],
+            };
+        }
+    });
+}

package/dist/tools/get-wiki-page.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerGetWikiPage(server: McpServer): void;

package/dist/tools/get-wiki-page.js

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import { fetchWikiPage } from '../data/wiki-client.js';
+export function registerGetWikiPage(server) {
+    server.registerTool('get_wiki_page', {
+        title: 'Get S&box Wiki Page',
+        description: 'Fetch a specific s&box wiki documentation page as raw markdown. Use search_wiki to find page paths, or provide a known path directly.',
+        inputSchema: {
+            path: z
+                .string()
+                .describe("Wiki page path (e.g., 'scene/components', 'networking/rpc-messages', 'getting-started/first-project')"),
+        },
+    }, async ({ path }) => {
+        try {
+            const { content, url } = await fetchWikiPage(path);
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Source: ${url}\n\n---\n\n${content}`,
+                    }],
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Error fetching wiki page: ${message}\n\nTip: Use search_wiki to find valid page paths.`,
+                    }],
+            };
+        }
+    });
+}

package/dist/tools/search-packages.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerSearchPackages(server: McpServer): void;

package/dist/tools/search-packages.js

@@ -0,0 +1,76 @@
+import { z } from 'zod';
+import { searchPackages, PACKAGE_TYPES } from '../data/ugc-client.js';
+function formatPackage(pkg, index) {
+    const lines = [];
+    const votes = pkg.VotesUp ? ` | Votes: ${pkg.VotesUp}` : '';
+    const favs = pkg.Favourited ? ` | Favs: ${pkg.Favourited}` : '';
+    const tags = pkg.Tags?.length ? `Tags: ${pkg.Tags.join(', ')}` : '';
+    lines.push(`${index + 1}. **${pkg.FullIdent}** — "${pkg.Title}"`);
+    if (pkg.Summary)
+        lines.push(`   ${pkg.Summary}`);
+    lines.push(`   Type: ${pkg.TypeName}${votes}${favs}`);
+    if (tags)
+        lines.push(`   ${tags}`);
+    lines.push(`   Use in code: \`${pkg.FullIdent}\``);
+    return lines.join('\n');
+}
+export function registerSearchPackages(server) {
+    server.registerTool('search_packages', {
+        title: 'Search S&box Workshop Packages',
+        description: 'Search the S&box Workshop (UGC) for community-made assets: models, sounds, materials, maps, prefabs, shaders, clothing, and more. Returns packages with their identifiers that can be used directly in S&box game code.',
+        inputSchema: {
+            query: z.string().describe("Search query (e.g., 'zombie', 'wooden chair', 'footstep sound')"),
+            type: z
+                .enum(PACKAGE_TYPES)
+                .optional()
+                .describe('Filter by asset type: model, sound, material, map, game, clothing, library, vsnd, prefab, shader'),
+            category: z
+                .string()
+                .optional()
+                .describe('Filter by category (for models: Animal, Architecture, Debris, Development, Fence/Wall, Food, Furniture, Human, Lighting, Nature, Prop, Toy, Vehicle, Weapon)'),
+            tag: z.string().optional().describe("Filter by tag (e.g., 'kenney', 'retro', 'psx', 'realistic')"),
+            order: z
+                .enum(['popular', 'newest', 'updated', 'trending', 'thumbsup', 'favourites'])
+                .optional()
+                .describe('Sort order. Defaults to relevance.'),
+            take: z.number().min(1).max(50).default(10).describe('Max results (1-50, default 10)'),
+        },
+    }, async ({ query, type, category, tag, order, take }) => {
+        try {
+            const response = await searchPackages({ query, type, category, tag, order, take });
+            if (response.Packages.length === 0) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `No packages found matching "${query}"${type ? ` (type: ${type})` : ''}. Try broadening your search or removing filters.`,
+                        }],
+                };
+            }
+            const formatted = response.Packages.map((pkg, i) => formatPackage(pkg, i));
+            const typeLabel = type ? ` (type: ${type})` : '';
+            const header = `Found ${response.TotalCount} packages matching "${query}"${typeLabel} (showing ${response.Packages.length}):\n`;
+            const topTags = response.Tags
+                ? Object.entries(response.Tags)
+                    .sort(([, a], [, b]) => b - a)
+                    .slice(0, 10)
+                    .map(([t, c]) => `${t} (${c})`)
+                    .join(', ')
+                : null;
+            const footer = topTags ? `\n---\nTop tags in results: ${topTags}` : '';
+            return {
+                content: [{
+                        type: 'text',
+                        text: `${header}\n${formatted.join('\n\n')}${footer}`,
+                    }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Error searching packages: ${err instanceof Error ? err.message : String(err)}`,
+                    }],
+            };
+        }
+    });
+}

package/dist/tools/search-wiki.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerSearchWiki(server: McpServer): void;

package/dist/tools/search-wiki.js

@@ -0,0 +1,68 @@
+import { z } from 'zod';
+import { searchWikiIndex, getWikiSections } from '../data/wiki-client.js';
+function formatEntry(entry, index) {
+    const slug = entry.path.replace('/dev/doc/', '').replace(/\.md$/, '');
+    return `${index + 1}. **${entry.title}** [${entry.section}]\n   Path: ${slug}`;
+}
+export function registerSearchWiki(server) {
+    server.registerTool('search_wiki', {
+        title: 'Search S&box Wiki Documentation',
+        description: 'Search the s&box wiki documentation for guides, tutorials, and conceptual docs. Returns matching page titles with paths. Use get_wiki_page with a path to read a specific page.',
+        inputSchema: {
+            query: z
+                .string()
+                .default('')
+                .describe("Topic to search for (e.g., 'networking', 'components', 'shader graph'). Leave empty to list sections or browse."),
+            section: z
+                .string()
+                .optional()
+                .describe("Filter by documentation section (e.g., 'Scene', 'Networking', 'Graphics', 'UI', 'Editor', 'Gameplay', 'Getting Started')"),
+            limit: z.number().min(1).max(50).default(10).describe('Max results (1-50, default 10)'),
+        },
+    }, async ({ query, section, limit }) => {
+        try {
+            // No query and no section: show sections overview
+            if (!query && !section) {
+                const sections = await getWikiSections();
+                const lines = Array.from(sections.entries())
+                    .sort(([, a], [, b]) => b - a)
+                    .map(([name, count]) => `- **${name}** (${count} pages)`);
+                const total = Array.from(sections.values()).reduce((a, b) => a + b, 0);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `S&box Wiki Documentation — ${total} pages in ${sections.size} sections:\n\n${lines.join('\n')}\n\nTip: Use search_wiki with a query or section to find specific pages.`,
+                        }],
+                };
+            }
+            const results = await searchWikiIndex(query, section, limit);
+            if (results.length === 0) {
+                const hint = section ? ` in section "${section}"` : '';
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `No wiki pages found matching "${query}"${hint}. Try broadening your search or removing the section filter.`,
+                        }],
+                };
+            }
+            const formatted = results.map((entry, i) => formatEntry(entry, i));
+            const sectionLabel = section ? ` in "${section}"` : '';
+            const queryLabel = query ? `matching "${query}"` : '';
+            const header = `Found ${results.length} wiki pages ${queryLabel}${sectionLabel}:\n`;
+            return {
+                content: [{
+                        type: 'text',
+                        text: `${header}\n${formatted.join('\n\n')}\n\nTip: Use get_wiki_page with the path to read a page.`,
+                    }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Error searching wiki: ${err instanceof Error ? err.message : String(err)}`,
+                    }],
+            };
+        }
+    });
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sbox-api-mcp",
-  "version": "1.0.0",
-  "description": "MCP server for S&box game engine API documentation lookup. Search types, methods, properties, and documentation across the entire S&box API.",
+  "version": "1.2.0",
+  "description": "MCP server for S&box game engine — API reference, wiki documentation, and Workshop (UGC) asset search. Search types, methods, properties, wiki guides/tutorials, and community-made models, sounds, maps, and more.",
   "type": "module",
   "bin": {
     "sbox-api-mcp": "dist/index.js"
@@ -25,7 +25,12 @@
     "api",
     "documentation",
     "claude",
-    "claude-code"
+    "claude-code",
+    "wiki",
+    "ugc",
+    "workshop",
+    "assets",
+    "models"
   ],
   "author": "sofianebel",
   "license": "MIT",