@skilljack/mcp 0.3.0

package/dist/roots-handler.js

@@ -0,0 +1,199 @@
+/**
+ * MCP Roots handler for dynamic skill discovery.
+ *
+ * Requests roots from the client, scans for skills in each root,
+ * and handles root change notifications.
+ *
+ * Pattern adapted from:
+ * - .claude/skills/mcp-server-ts/snippets/server/index.ts (oninitialized, syncRoots)
+ * - .claude/skills/mcp-client-ts/snippets/handlers/roots.ts (URI conversion)
+ */
+import { RootsListChangedNotificationSchema } from "@modelcontextprotocol/sdk/types.js";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { discoverSkills, generateInstructions, createSkillMap, } from "./skill-discovery.js";
+/**
+ * Skill discovery locations within each root.
+ */
+export const SKILL_SUBDIRS = [".claude/skills", "skills"];
+/**
+ * Convert a file:// URI to a filesystem path.
+ * Adapted from mcp-client-ts roots.ts pathToRoot() (reverse direction).
+ */
+function uriToPath(uri) {
+    return fileURLToPath(new URL(uri));
+}
+/**
+ * Discover skills from all roots provided by the client.
+ *
+ * Scans each root for skill directories (.claude/skills/, skills/)
+ * and handles naming conflicts by prefixing with root name.
+ *
+ * @param roots - Array of Root objects from client's roots/list response
+ * @returns Object containing discovered skills
+ */
+export function discoverSkillsFromRoots(roots) {
+    const allSkills = [];
+    const rootSources = new Map(); // skill path -> root name
+    const nameCount = new Map(); // track duplicates
+    for (const root of roots) {
+        let rootPath;
+        try {
+            rootPath = uriToPath(root.uri);
+        }
+        catch (error) {
+            console.error(`Failed to parse root URI "${root.uri}":`, error);
+            continue;
+        }
+        const rootName = root.name || path.basename(rootPath);
+        for (const subdir of SKILL_SUBDIRS) {
+            const skillsDir = path.join(rootPath, subdir);
+            if (fs.existsSync(skillsDir)) {
+                try {
+                    const skills = discoverSkills(skillsDir);
+                    for (const skill of skills) {
+                        // Track which root this skill came from
+                        rootSources.set(skill.path, rootName);
+                        // Count occurrences of each name
+                        const count = (nameCount.get(skill.name) || 0) + 1;
+                        nameCount.set(skill.name, count);
+                        allSkills.push(skill);
+                    }
+                }
+                catch (error) {
+                    console.error(`Failed to discover skills in "${skillsDir}":`, error);
+                }
+            }
+        }
+    }
+    // Handle naming conflicts by prefixing duplicates with root name
+    for (const skill of allSkills) {
+        if (nameCount.get(skill.name) > 1) {
+            const rootName = rootSources.get(skill.path);
+            skill.name = `${rootName}:${skill.name}`;
+        }
+    }
+    return { skills: allSkills, rootSources };
+}
+/**
+ * Discover skills from a directory, checking both the directory itself
+ * and SKILL_SUBDIRS subdirectories.
+ */
+function discoverSkillsFromDirectory(skillsDir) {
+    const allSkills = [];
+    // Check if the directory itself contains skills
+    const directSkills = discoverSkills(skillsDir);
+    allSkills.push(...directSkills);
+    // Also check SKILL_SUBDIRS subdirectories
+    for (const subdir of SKILL_SUBDIRS) {
+        const subPath = path.join(skillsDir, subdir);
+        if (fs.existsSync(subPath)) {
+            const subdirSkills = discoverSkills(subPath);
+            allSkills.push(...subdirSkills);
+        }
+    }
+    return allSkills;
+}
+/**
+ * Sync skills from roots or configured skills directory.
+ *
+ * Pattern from mcp-server-ts snippets/server/index.ts:
+ * - Check client capabilities
+ * - Request roots if supported
+ * - Use skills directory if not
+ *
+ * @param server - The McpServer instance
+ * @param skillsDir - Optional skills directory if client doesn't support roots
+ * @param onSkillsChanged - Callback when skills are updated
+ */
+export async function syncSkills(server, skillsDir, onSkillsChanged) {
+    const capabilities = server.server.getClientCapabilities();
+    const allSkills = [];
+    const seenNames = new Set();
+    // Always discover from configured skills directory first
+    if (skillsDir) {
+        const dirSkills = discoverSkillsFromDirectory(skillsDir);
+        console.error(`Discovered ${dirSkills.length} skill(s) from skills directory`);
+        for (const skill of dirSkills) {
+            if (!seenNames.has(skill.name)) {
+                seenNames.add(skill.name);
+                allSkills.push(skill);
+            }
+        }
+    }
+    // Also discover from roots if client supports them
+    if (capabilities?.roots) {
+        console.error("Client supports roots, requesting workspace roots...");
+        try {
+            const { roots } = await server.server.listRoots();
+            console.error(`Received ${roots.length} root(s) from client`);
+            const { skills: rootSkills } = discoverSkillsFromRoots(roots);
+            console.error(`Discovered ${rootSkills.length} skill(s) from roots`);
+            // Add roots skills, skipping duplicates (skillsDir takes precedence)
+            for (const skill of rootSkills) {
+                if (!seenNames.has(skill.name)) {
+                    seenNames.add(skill.name);
+                    allSkills.push(skill);
+                }
+            }
+            // Listen for roots changes if client supports listChanged
+            if (capabilities.roots.listChanged) {
+                setupRootsChangeHandler(server, skillsDir, onSkillsChanged);
+            }
+        }
+        catch (error) {
+            console.error("Failed to get roots from client:", error);
+        }
+    }
+    else {
+        console.error("Client does not support roots");
+    }
+    console.error(`Total skills available: ${allSkills.length}`);
+    const skillMap = createSkillMap(allSkills);
+    const instructions = generateInstructions(allSkills);
+    onSkillsChanged(skillMap, instructions);
+}
+/**
+ * Set up handler for roots/list_changed notifications.
+ */
+function setupRootsChangeHandler(server, skillsDir, onSkillsChanged) {
+    server.server.setNotificationHandler(RootsListChangedNotificationSchema, async () => {
+        console.error("Roots changed notification received, re-discovering skills...");
+        try {
+            const allSkills = [];
+            const seenNames = new Set();
+            // Always include skills from configured directory first
+            if (skillsDir) {
+                const dirSkills = discoverSkillsFromDirectory(skillsDir);
+                for (const skill of dirSkills) {
+                    if (!seenNames.has(skill.name)) {
+                        seenNames.add(skill.name);
+                        allSkills.push(skill);
+                    }
+                }
+            }
+            // Add skills from roots
+            const { roots } = await server.server.listRoots();
+            const { skills: rootSkills } = discoverSkillsFromRoots(roots);
+            console.error(`Re-discovered ${rootSkills.length} skill(s) from updated roots`);
+            for (const skill of rootSkills) {
+                if (!seenNames.has(skill.name)) {
+                    seenNames.add(skill.name);
+                    allSkills.push(skill);
+                }
+            }
+            console.error(`Total skills available: ${allSkills.length}`);
+            const skillMap = createSkillMap(allSkills);
+            const instructions = generateInstructions(allSkills);
+            onSkillsChanged(skillMap, instructions);
+            // Notify client that resources have changed
+            await server.server.notification({
+                method: "notifications/resources/list_changed",
+            });
+        }
+        catch (error) {
+            console.error("Failed to re-discover skills after roots change:", error);
+        }
+    });
+}

package/dist/skill-discovery.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Skill discovery and metadata parsing module.
+ *
+ * Discovers Agent Skills from a directory, parses YAML frontmatter,
+ * and generates server instructions XML.
+ */
+/**
+ * Metadata extracted from a skill's SKILL.md frontmatter.
+ */
+export interface SkillMetadata {
+    name: string;
+    description: string;
+    path: string;
+}
+/**
+ * Discover all skills in a directory.
+ * Scans for subdirectories containing SKILL.md files.
+ */
+export declare function discoverSkills(skillsDir: string): SkillMetadata[];
+/**
+ * Generate the server instructions with available skills.
+ * Includes a brief preamble about skill usage following the Agent Skills spec.
+ */
+export declare function generateInstructions(skills: SkillMetadata[]): string;
+/**
+ * Load the full content of a skill's SKILL.md file.
+ */
+export declare function loadSkillContent(skillPath: string): string;
+/**
+ * Create a map from skill name to skill metadata for fast lookup.
+ * Uses first-wins behavior: if duplicate names exist, the first occurrence is kept.
+ */
+export declare function createSkillMap(skills: SkillMetadata[]): Map<string, SkillMetadata>;

package/dist/skill-discovery.js

@@ -0,0 +1,144 @@
+/**
+ * Skill discovery and metadata parsing module.
+ *
+ * Discovers Agent Skills from a directory, parses YAML frontmatter,
+ * and generates server instructions XML.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { parse as parseYaml } from "yaml";
+/**
+ * Find the SKILL.md file in a skill directory.
+ * Prefers SKILL.md (uppercase) but accepts skill.md (lowercase).
+ */
+function findSkillMd(skillDir) {
+    for (const name of ["SKILL.md", "skill.md"]) {
+        const filePath = path.join(skillDir, name);
+        if (fs.existsSync(filePath)) {
+            return filePath;
+        }
+    }
+    return null;
+}
+/**
+ * Parse YAML frontmatter from SKILL.md content.
+ * Returns the parsed metadata and the markdown body.
+ */
+function parseFrontmatter(content) {
+    if (!content.startsWith("---")) {
+        throw new Error("SKILL.md must start with YAML frontmatter (---)");
+    }
+    const parts = content.split("---");
+    if (parts.length < 3) {
+        throw new Error("SKILL.md frontmatter not properly closed with ---");
+    }
+    const frontmatterStr = parts[1];
+    const body = parts.slice(2).join("---").trim();
+    const metadata = parseYaml(frontmatterStr);
+    if (typeof metadata !== "object" || metadata === null) {
+        throw new Error("SKILL.md frontmatter must be a YAML mapping");
+    }
+    return { metadata, body };
+}
+/**
+ * Discover all skills in a directory.
+ * Scans for subdirectories containing SKILL.md files.
+ */
+export function discoverSkills(skillsDir) {
+    const skills = [];
+    if (!fs.existsSync(skillsDir)) {
+        console.error(`Skills directory not found: ${skillsDir}`);
+        return skills;
+    }
+    const entries = fs.readdirSync(skillsDir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const skillDir = path.join(skillsDir, entry.name);
+        const skillMdPath = findSkillMd(skillDir);
+        if (!skillMdPath)
+            continue;
+        try {
+            const content = fs.readFileSync(skillMdPath, "utf-8");
+            const { metadata } = parseFrontmatter(content);
+            const name = metadata.name;
+            const description = metadata.description;
+            if (typeof name !== "string" || !name.trim()) {
+                console.error(`Skill at ${skillDir}: missing or invalid 'name' field`);
+                continue;
+            }
+            if (typeof description !== "string" || !description.trim()) {
+                console.error(`Skill at ${skillDir}: missing or invalid 'description' field`);
+                continue;
+            }
+            skills.push({
+                name: name.trim(),
+                description: description.trim(),
+                path: skillMdPath,
+            });
+        }
+        catch (error) {
+            console.error(`Failed to parse skill at ${skillDir}:`, error);
+        }
+    }
+    return skills;
+}
+/**
+ * Escape special XML characters.
+ */
+function escapeXml(str) {
+    return str
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&apos;");
+}
+/**
+ * Generate the server instructions with available skills.
+ * Includes a brief preamble about skill usage following the Agent Skills spec.
+ */
+export function generateInstructions(skills) {
+    const preamble = `# Skills
+
+When a user's task matches a skill description below: 1) activate it, 2) follow its instructions completely.
+
+`;
+    if (skills.length === 0) {
+        return preamble + "<available_skills>\n</available_skills>";
+    }
+    const lines = ["<available_skills>"];
+    for (const skill of skills) {
+        lines.push("<skill>");
+        lines.push(`<name>${escapeXml(skill.name)}</name>`);
+        lines.push(`<description>${escapeXml(skill.description)}</description>`);
+        lines.push(`<location>${escapeXml(skill.path)}</location>`);
+        lines.push("</skill>");
+    }
+    lines.push("</available_skills>");
+    return preamble + lines.join("\n");
+}
+/**
+ * Load the full content of a skill's SKILL.md file.
+ */
+export function loadSkillContent(skillPath) {
+    return fs.readFileSync(skillPath, "utf-8");
+}
+/**
+ * Create a map from skill name to skill metadata for fast lookup.
+ * Uses first-wins behavior: if duplicate names exist, the first occurrence is kept.
+ */
+export function createSkillMap(skills) {
+    const map = new Map();
+    for (const skill of skills) {
+        if (map.has(skill.name)) {
+            const existing = map.get(skill.name);
+            console.error(`Warning: Duplicate skill name "${skill.name}" found at ${skill.path} - ` +
+                `keeping first occurrence from ${existing.path}`);
+        }
+        else {
+            map.set(skill.name, skill);
+        }
+    }
+    return map;
+}

package/dist/skill-resources.d.ts

@@ -0,0 +1,26 @@
+/**
+ * MCP Resource registration for skill-based resources.
+ *
+ * Resources provide application-controlled access to skill content,
+ * complementing the model-controlled tool access.
+ *
+ * All resources use templates with dynamic list callbacks to support
+ * skill updates when MCP roots change.
+ *
+ * URI Scheme:
+ *   skill://{skillName}         -> SKILL.md content (template)
+ *   skill://{skillName}/        -> Collection: all files in skill directory
+ *   skill://{skillName}/{path}  -> File within skill directory (template)
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { SkillState } from "./skill-tool.js";
+/**
+ * Register skill resources with the MCP server.
+ *
+ * All resources use templates with dynamic list callbacks to support
+ * skill updates when MCP roots change.
+ *
+ * @param server - The McpServer instance
+ * @param skillState - Shared state object (allows dynamic updates)
+ */
+export declare function registerSkillResources(server: McpServer, skillState: SkillState): void;

package/dist/skill-resources.js

@@ -0,0 +1,286 @@
+/**
+ * MCP Resource registration for skill-based resources.
+ *
+ * Resources provide application-controlled access to skill content,
+ * complementing the model-controlled tool access.
+ *
+ * All resources use templates with dynamic list callbacks to support
+ * skill updates when MCP roots change.
+ *
+ * URI Scheme:
+ *   skill://{skillName}         -> SKILL.md content (template)
+ *   skill://{skillName}/        -> Collection: all files in skill directory
+ *   skill://{skillName}/{path}  -> File within skill directory (template)
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { loadSkillContent } from "./skill-discovery.js";
+import { isPathWithinBase, listSkillFiles, MAX_FILE_SIZE } from "./skill-tool.js";
+/**
+ * Get MIME type based on file extension.
+ */
+function getMimeType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    const mimeTypes = {
+        ".md": "text/markdown",
+        ".ts": "text/typescript",
+        ".js": "text/javascript",
+        ".json": "application/json",
+        ".yaml": "text/yaml",
+        ".yml": "text/yaml",
+        ".txt": "text/plain",
+        ".sh": "text/x-shellscript",
+        ".py": "text/x-python",
+        ".css": "text/css",
+        ".html": "text/html",
+        ".xml": "application/xml",
+    };
+    return mimeTypes[ext] || "text/plain";
+}
+/**
+ * Register skill resources with the MCP server.
+ *
+ * All resources use templates with dynamic list callbacks to support
+ * skill updates when MCP roots change.
+ *
+ * @param server - The McpServer instance
+ * @param skillState - Shared state object (allows dynamic updates)
+ */
+export function registerSkillResources(server, skillState) {
+    // Register template for individual skill SKILL.md files
+    registerSkillTemplate(server, skillState);
+    // Register collection resource for skill directories (must be before file template)
+    registerSkillDirectoryCollection(server, skillState);
+    // Register resource template for skill files
+    registerSkillFileTemplate(server, skillState);
+}
+/**
+ * Register a collection resource for skill directories.
+ *
+ * URI Pattern: skill://{skillName}/
+ *
+ * Returns all files in the skill directory (excluding SKILL.md) in a single request.
+ * This allows clients to fetch all resource files for a skill at once.
+ */
+function registerSkillDirectoryCollection(server, skillState) {
+    server.registerResource("Skill Directory", new ResourceTemplate("skill://{skillName}/", {
+        list: async () => {
+            // Return one entry per skill (the directory collection)
+            const resources = [];
+            for (const [name, skill] of skillState.skillMap) {
+                resources.push({
+                    uri: `skill://${encodeURIComponent(name)}/`,
+                    name: `${name}/`,
+                    mimeType: "text/plain",
+                    description: `All files in ${name} skill directory`,
+                });
+            }
+            return { resources };
+        },
+        complete: {
+            skillName: (value) => {
+                const names = Array.from(skillState.skillMap.keys());
+                return names.filter((n) => n.toLowerCase().startsWith(value.toLowerCase()));
+            },
+        },
+    }), {
+        mimeType: "text/plain",
+        description: "Collection of all files in a skill directory (excluding SKILL.md)",
+    }, async (resourceUri) => {
+        // Extract skill name from URI
+        const uriStr = resourceUri.toString();
+        const match = uriStr.match(/^skill:\/\/([^/]+)\/$/);
+        if (!match) {
+            throw new Error(`Invalid skill directory URI: ${uriStr}`);
+        }
+        const skillName = decodeURIComponent(match[1]);
+        const skill = skillState.skillMap.get(skillName);
+        if (!skill) {
+            const available = Array.from(skillState.skillMap.keys()).join(", ");
+            throw new Error(`Skill "${skillName}" not found. Available: ${available || "none"}`);
+        }
+        const skillDir = path.dirname(skill.path);
+        const files = listSkillFiles(skillDir);
+        const contents = [];
+        for (const file of files) {
+            const fullPath = path.join(skillDir, file);
+            // Security: Validate path is within skill directory
+            if (!isPathWithinBase(fullPath, skillDir)) {
+                continue; // Skip files outside skill directory
+            }
+            try {
+                const stat = fs.statSync(fullPath);
+                // Skip symlinks and directories
+                if (stat.isSymbolicLink() || stat.isDirectory()) {
+                    continue;
+                }
+                // Check file size
+                if (stat.size > MAX_FILE_SIZE) {
+                    continue; // Skip large files
+                }
+                const content = fs.readFileSync(fullPath, "utf-8");
+                contents.push({
+                    uri: `skill://${encodeURIComponent(skillName)}/${file}`,
+                    mimeType: getMimeType(file),
+                    text: content,
+                });
+            }
+            catch (error) {
+                // Skip files that fail to load
+                console.error(`Failed to load file "${file}" in skill "${skillName}":`, error);
+            }
+        }
+        return { contents };
+    });
+}
+/**
+ * Register a template for individual skill SKILL.md resources.
+ *
+ * URI Pattern: skill://{skillName}
+ *
+ * Uses a template with a list callback to dynamically return available skills.
+ */
+function registerSkillTemplate(server, skillState) {
+    server.registerResource("Skill", new ResourceTemplate("skill://{skillName}", {
+        list: async () => {
+            // Dynamically return current skills
+            const resources = [];
+            for (const [name, skill] of skillState.skillMap) {
+                resources.push({
+                    uri: `skill://${encodeURIComponent(name)}`,
+                    name,
+                    mimeType: "text/markdown",
+                    description: skill.description,
+                });
+            }
+            return { resources };
+        },
+        complete: {
+            skillName: (value) => {
+                const names = Array.from(skillState.skillMap.keys());
+                return names.filter((name) => name.toLowerCase().startsWith(value.toLowerCase()));
+            },
+        },
+    }), {
+        mimeType: "text/markdown",
+        description: "SKILL.md content for a skill",
+    }, async (resourceUri) => {
+        // Extract skill name from URI
+        const uriStr = resourceUri.toString();
+        const match = uriStr.match(/^skill:\/\/([^/]+)$/);
+        if (!match) {
+            throw new Error(`Invalid skill URI: ${uriStr}`);
+        }
+        const skillName = decodeURIComponent(match[1]);
+        const skill = skillState.skillMap.get(skillName);
+        if (!skill) {
+            const available = Array.from(skillState.skillMap.keys()).join(", ");
+            throw new Error(`Skill "${skillName}" not found. Available: ${available || "none"}`);
+        }
+        try {
+            const content = loadSkillContent(skill.path);
+            return {
+                contents: [
+                    {
+                        uri: uriStr,
+                        mimeType: "text/markdown",
+                        text: content,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to load skill "${skillName}": ${message}`);
+        }
+    });
+}
+/**
+ * Register the resource template for accessing files within skills.
+ *
+ * URI Pattern: skill://{skillName}/{filePath}
+ */
+function registerSkillFileTemplate(server, skillState) {
+    server.registerResource("Skill File", new ResourceTemplate("skill://{skillName}/{+filePath}", {
+        list: async () => {
+            // Return all listable skill files (dynamic based on current skillMap)
+            const resources = [];
+            for (const [name, skill] of skillState.skillMap) {
+                const skillDir = path.dirname(skill.path);
+                const files = listSkillFiles(skillDir);
+                for (const file of files) {
+                    const uri = `skill://${encodeURIComponent(name)}/${file}`;
+                    resources.push({
+                        uri,
+                        name: `${name}/${file}`,
+                        mimeType: getMimeType(file),
+                    });
+                }
+            }
+            return { resources };
+        },
+        complete: {
+            skillName: (value) => {
+                const names = Array.from(skillState.skillMap.keys());
+                return names.filter((name) => name.toLowerCase().startsWith(value.toLowerCase()));
+            },
+        },
+    }), {
+        mimeType: "text/plain",
+        description: "Files within a skill directory (scripts, snippets, assets, etc.)",
+    }, async (resourceUri, variables) => {
+        // Extract skill name and file path from URI
+        const uriStr = resourceUri.toString();
+        const match = uriStr.match(/^skill:\/\/([^/]+)\/(.+)$/);
+        if (!match) {
+            throw new Error(`Invalid skill file URI: ${uriStr}`);
+        }
+        const skillName = decodeURIComponent(match[1]);
+        const filePath = match[2];
+        const skill = skillState.skillMap.get(skillName);
+        if (!skill) {
+            const available = Array.from(skillState.skillMap.keys()).join(", ");
+            throw new Error(`Skill "${skillName}" not found. Available: ${available || "none"}`);
+        }
+        const skillDir = path.dirname(skill.path);
+        const fullPath = path.resolve(skillDir, filePath);
+        // Security: Validate path is within skill directory
+        if (!isPathWithinBase(fullPath, skillDir)) {
+            throw new Error(`Path "${filePath}" is outside the skill directory`);
+        }
+        // Check file exists
+        if (!fs.existsSync(fullPath)) {
+            const files = listSkillFiles(skillDir).slice(0, 10);
+            throw new Error(`File "${filePath}" not found in skill "${skillName}". ` +
+                `Available: ${files.join(", ")}${files.length >= 10 ? "..." : ""}`);
+        }
+        const stat = fs.statSync(fullPath);
+        // Reject symlinks
+        if (stat.isSymbolicLink()) {
+            throw new Error(`Cannot read symlink "${filePath}"`);
+        }
+        // Reject directories
+        if (stat.isDirectory()) {
+            const files = listSkillFiles(skillDir, filePath);
+            throw new Error(`"${filePath}" is a directory. Files within: ${files.join(", ")}`);
+        }
+        // Check file size
+        if (stat.size > MAX_FILE_SIZE) {
+            const sizeMB = (stat.size / 1024 / 1024).toFixed(2);
+            throw new Error(`File too large (${sizeMB}MB). Maximum: 10MB`);
+        }
+        // Read and return content
+        const content = fs.readFileSync(fullPath, "utf-8");
+        const mimeType = getMimeType(fullPath);
+        return {
+            contents: [
+                {
+                    uri: uriStr,
+                    mimeType,
+                    text: content,
+                },
+            ],
+        };
+    });
+}