homeskill 1.0.0

package/README.md

@@ -0,0 +1,62 @@
+# HomeSkill CLI
+
+> The Skill to manage Skills 🚀
+
+**HomeSkill** is the official package manager for Claude Skills (MCP). It allows you to search, install, manage, and share skills for your AI agents directly from your terminal.
+
+[![npm version](https://img.shields.io/npm/v/homeskill.svg)](https://www.npmjs.com/package/homeskill)
+[![HomeSkill](https://img.shields.io/badge/Website-homeskill.org-7038F1)](https://homeskill.org)
+
+## ✨ Features
+
+- **Store**: Access hundreds of verified skills from the HomeSkill registry.
+- **Easy Install**: `homeskill install <name>` - no more manual zip handling.
+- **Management**: List and update your skills effortlessly.
+- **Publish**: Share your own skills with the community via `homeskill upload`.
+- **Secure**: All skills are reviewed and verified.
+
+## 📦 Installation
+
+```bash
+npm install -g homeskill
+```
+
+## 🚀 Usage
+
+### Search Skills
+Find the perfect tool for your agent:
+```bash
+homeskill search "pdf"
+homeskill search "web scraper"
+```
+
+### Install a Skill
+Download and configure a skill in seconds:
+```bash
+homeskill install "google-search"
+```
+
+### List Installed Skills
+See what you have installed locally:
+```bash
+homeskill list
+```
+
+### Publish Your Skill
+Created a new MCP server? Share it with the world!
+1. Go to your skill directory
+2. Run:
+```bash
+homeskill login
+homeskill upload my-skill-name
+```
+
+## 🌐 Links
+
+- **Website**: [homeskill.org](https://homeskill.org)
+- **Documentation**: [docs.homeskill.org](https://homeskill.org/docs)
+- **GitHub**: [github.com/Start-Z-Labs/homeskill-web](https://github.com/Start-Z-Labs/homeskill-web)
+
+## 📄 License
+
+MIT © [HomeSkill Team](https://homeskill.org)

package/dist/index.js

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const open_1 = __importDefault(require("open"));
+const uuid_1 = require("uuid");
+const api_1 = require("./lib/api");
+const manager_1 = require("./lib/manager");
+const program = new commander_1.Command();
+program
+    .name('homeskill')
+    .description('The Skill to manage Skills')
+    .version('1.0.0')
+    .hook('preAction', () => {
+    console.log(chalk_1.default.bold.hex('#7038F1')('🚀 HomeSkill CLI') + chalk_1.default.gray(' - The Skill to manage Skills (https://homeskill.org)\n'));
+});
+// --- Auth Commands ---
+program
+    .command('login')
+    .description('Authenticate with HomeSkill')
+    .action(async () => {
+    const requestId = (0, uuid_1.v4)();
+    const webBase = process.env.HOMESKILL_WEB_BASE || "https://homeskill.org";
+    const authUrl = `${webBase}/#/auth/cli?request_id=${requestId}`;
+    console.log(chalk_1.default.blue(`🔌 Connecting to HomeSkill login...`));
+    console.log(`\n🔑 Please authenticate in your browser:`);
+    console.log(chalk_1.default.underline(authUrl));
+    console.log(`\n(Press Ctrl+C to cancel)`);
+    try {
+        await (0, open_1.default)(authUrl);
+    }
+    catch (e) {
+        console.log(chalk_1.default.yellow("Could not open browser automatically. Please copy the link above."));
+    }
+    console.log(`\nWaiting for confirmation...`);
+    // Poll loop
+    const start = Date.now();
+    const TIMEOUT = 300 * 1000; // 5 min
+    const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+    while (Date.now() - start < TIMEOUT) {
+        try {
+            const res = await api_1.client.pollAuth(requestId);
+            if (res && res.status === 'approved') {
+                await api_1.client.saveCredentials(res.access_token, res.refresh_token, res.user_id);
+                console.log(chalk_1.default.green(`\n✅ Login Successful!`));
+                return;
+            }
+            else if (res && res.status === 'expired') {
+                console.log(chalk_1.default.red(`\n❌ Login session expired.`));
+                process.exit(1);
+            }
+        }
+        catch (e) {
+            // 410 Gone, etc
+            if (e.response && e.response.status === 410) {
+                console.log(chalk_1.default.red(`\n❌ Login session expired.`));
+                process.exit(1);
+            }
+        }
+        process.stdout.write(chalk_1.default.gray("."));
+        await sleep(2000);
+    }
+    console.log(chalk_1.default.red(`\n❌ Login timed out.`));
+    process.exit(1);
+});
+// --- Skill Commands ---
+program
+    .command('search <query>')
+    .description('Search for skills')
+    .option('-t, --tag <tag>', 'Filter by tag')
+    .option('-l, --limit <number>', 'Limit results', '10')
+    .action(async (query, options) => {
+    try {
+        console.log(chalk_1.default.blue(`Searching for skills matching: ${query}...`));
+        const skills = await api_1.client.searchSkills(query, options.tag, parseInt(options.limit));
+        console.log(chalk_1.default.green(`Found ${skills.length} skills:`));
+        skills.forEach(skill => {
+            console.log(chalk_1.default.bold(`\n${skill.name}`) + ` (v${skill.latest_version})` + chalk_1.default.gray(` by ${skill.author}`));
+            console.log(`  ${skill.short_description}`);
+            const rating = skill.avg_rating ? `⭐ ${skill.avg_rating.toFixed(1)}` : 'No ratings';
+            console.log(chalk_1.default.yellow(`  ${rating} | 📥 ${skill.installs_count || 0} installs`));
+            console.log(chalk_1.default.gray(`  ID: ${skill.id}`));
+        });
+    }
+    catch (e) {
+        console.error(chalk_1.default.red(`Search failed: ${e.message}`));
+    }
+});
+program
+    .command('install <skillId>')
+    .description('Install a skill')
+    .option('-f, --force', 'Overwrite existing skill')
+    .option('-n, --name <name>', 'Rename skill locally')
+    .action(async (skillId, options) => {
+    try {
+        console.log(chalk_1.default.blue(`Installing skill: ${skillId}...`));
+        const skill = await manager_1.manager.installSkill(skillId, options.name, options.force);
+        console.log(chalk_1.default.green(`\nSuccessfully installed ${skill.name} v${skill.version}!`));
+        console.log(`Location: ${skill.path}`);
+    }
+    catch (e) {
+        console.error(chalk_1.default.red(`Installation failed: ${e.message}`));
+    }
+});
+program
+    .command('list')
+    .description('List installed skills')
+    .action(async () => {
+    try {
+        const skills = await manager_1.manager.listLocalSkills();
+        console.log(chalk_1.default.blue(`Found ${skills.length} installed skills:`));
+        skills.forEach(skill => {
+            console.log(chalk_1.default.bold(`\n${skill.name}`) + ` (v${skill.version})`);
+            console.log(`  ${skill.description}`);
+            console.log(chalk_1.default.gray(`  Path: ${skill.path}`));
+        });
+    }
+    catch (e) {
+        console.error(chalk_1.default.red(`List failed: ${e.message}`));
+    }
+});
+program
+    .command('upload <skillName>')
+    .description('Upload a local skill to HomeSkill')
+    .option('--user <user>', 'User identifier (email/username)')
+    .action(async (skillName, options) => {
+    try {
+        console.log(chalk_1.default.blue(`Packaging skill: ${skillName}...`));
+        const { buffer, info } = await manager_1.manager.packageSkill(skillName);
+        console.log(`  Name: ${info.name}`);
+        console.log(`  Version: ${info.version}`);
+        console.log(`  Size: ${(buffer.length / 1024).toFixed(2)} KB`);
+        const user = options.user || process.env.HOMESKILL_USER_ID || "unknown";
+        console.log(chalk_1.default.blue(`Uploading as ${user}...`));
+        const res = await api_1.client.uploadSkill(buffer, user, `${skillName}.zip`);
+        if (res.pr_url) {
+            console.log(chalk_1.default.green(`\n✅ Upload successful! GitHub PR created:`));
+            console.log(chalk_1.default.bold(res.pr_url));
+            console.log(`\nReview the PR to have your skill published.`);
+        }
+        else {
+            console.log(chalk_1.default.green(`\n✅ Upload successful!`));
+            console.log(res);
+        }
+    }
+    catch (e) {
+        console.error(chalk_1.default.red(`Upload failed: ${e.message || e}`));
+        if (e.response) {
+            console.error(chalk_1.default.red(`Response: ${JSON.stringify(e.response.data)}`));
+        }
+    }
+});
+program.parse(process.argv);

package/dist/lib/api.js

@@ -0,0 +1,177 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.client = exports.HomeSkillClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const form_data_1 = __importDefault(require("form-data"));
+const DEFAULT_API_BASE = "https://homeskill-backend-42697595806.us-central1.run.app";
+const DEFAULT_SUPABASE_URL = "https://kfaursfbsvyqtmhyrgqm.supabase.co";
+const DEFAULT_SUPABASE_ANON_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImtmYXVyc2Zic3Z5cXRtaHlyZ3FtIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NjQ3NTM1OTcsImV4cCI6MjA4MDMyOTU5N30.qfpjo3rrXlXmx1hcFYBWCoYjc_WzKahUEfJNpgB6eBs";
+class HomeSkillClient {
+    apiBase;
+    apiToken = null;
+    refreshToken = null;
+    credPath;
+    constructor(apiBase) {
+        this.apiBase = (apiBase || process.env.HOMESKILL_API_BASE || DEFAULT_API_BASE).replace(/\/$/, "");
+        this.credPath = path_1.default.join(os_1.default.homedir(), ".homeskill", "credentials");
+        this.loadCredentials();
+        // Override with env var if present
+        if (process.env.HOMESKILL_API_TOKEN) {
+            this.apiToken = process.env.HOMESKILL_API_TOKEN;
+        }
+    }
+    loadCredentials() {
+        try {
+            if (fs_extra_1.default.existsSync(this.credPath)) {
+                const data = fs_extra_1.default.readJsonSync(this.credPath);
+                this.apiToken = data.access_token;
+                this.refreshToken = data.refresh_token;
+            }
+        }
+        catch (e) {
+            // Ignore
+        }
+    }
+    async saveCredentials(accessToken, refreshToken, userId) {
+        try {
+            await fs_extra_1.default.ensureDir(path_1.default.dirname(this.credPath));
+            const payload = {
+                access_token: accessToken,
+                refresh_token: refreshToken || this.refreshToken,
+                user_id: userId,
+                updated_at: Date.now() / 1000
+            };
+            await fs_extra_1.default.writeJson(this.credPath, payload, { spaces: 2 });
+            await fs_extra_1.default.chmod(this.credPath, 0o600);
+            this.apiToken = accessToken;
+            if (refreshToken)
+                this.refreshToken = refreshToken;
+        }
+        catch (e) {
+            // Ignore
+        }
+    }
+    async refreshAccessToken() {
+        if (!this.refreshToken)
+            return false;
+        const supabaseUrl = process.env.SUPABASE_URL || process.env.VITE_SUPABASE_URL || DEFAULT_SUPABASE_URL;
+        const supabaseAnon = process.env.SUPABASE_ANON_KEY || process.env.VITE_SUPABASE_ANON_KEY || DEFAULT_SUPABASE_ANON_KEY;
+        try {
+            const resp = await axios_1.default.post(`${supabaseUrl}/auth/v1/token?grant_type=refresh_token`, {
+                refresh_token: this.refreshToken
+            }, {
+                headers: {
+                    apikey: supabaseAnon,
+                    Authorization: `Bearer ${supabaseAnon}`,
+                    'Content-Type': 'application/json'
+                }
+            });
+            if (resp.data && resp.data.access_token) {
+                await this.saveCredentials(resp.data.access_token, resp.data.refresh_token, resp.data.user?.id);
+                return true;
+            }
+        }
+        catch (e) {
+            return false;
+        }
+        return false;
+    }
+    async request(method, endpoint, data, params, headers = {}, retry = true) {
+        const url = `${this.apiBase}${endpoint}`;
+        const reqHeaders = {
+            ...headers,
+            'Accept': 'application/json',
+            'User-Agent': 'HomeSkill-CLI/1.0',
+        };
+        if (this.apiToken && !reqHeaders['Authorization']) {
+            reqHeaders['Authorization'] = `Bearer ${this.apiToken}`;
+        }
+        try {
+            const response = await (0, axios_1.default)({
+                method,
+                url,
+                data,
+                params,
+                headers: reqHeaders,
+                responseType: endpoint.includes('download') ? 'arraybuffer' : 'json'
+            });
+            return response.data;
+        }
+        catch (error) {
+            if (retry && error.response && error.response.status === 401) {
+                const refreshed = await this.refreshAccessToken();
+                if (refreshed) {
+                    // Retry with new token
+                    return this.request(method, endpoint, data, params, headers, false);
+                }
+            }
+            throw error;
+        }
+    }
+    async searchSkills(query, tag, limit = 50) {
+        const params = { query, limit };
+        if (tag)
+            params.tag = tag;
+        const res = await this.request('GET', '/api/skills', null, params);
+        // Handle different response structures based on Python client experiences
+        let skillsData = [];
+        if (Array.isArray(res)) {
+            skillsData = res;
+        }
+        else {
+            skillsData = res.skills || res.data || res.results || [];
+        }
+        return skillsData.map((s) => this.mapSkillInfo(s));
+    }
+    async getSkillInfo(skillId) {
+        const res = await this.request('GET', `/api/skills/${encodeURIComponent(skillId)}`);
+        return this.mapSkillInfo(res);
+    }
+    async downloadSkill(skillId) {
+        const res = await this.request('POST', `/api/skills/${encodeURIComponent(skillId)}/download`);
+        const downloadUrl = res.download_url;
+        if (!downloadUrl)
+            throw new Error("No download URL returned");
+        const dlRes = await axios_1.default.get(downloadUrl, { responseType: 'arraybuffer' });
+        return Buffer.from(dlRes.data);
+    }
+    async uploadSkill(zipData, userIdentifier, filename = "skill.zip") {
+        const form = new form_data_1.default();
+        form.append('user_identifier', userIdentifier);
+        form.append('zip_file', zipData, { filename, contentType: 'application/zip' });
+        // form-data headers need to be passed correctly
+        const headers = form.getHeaders();
+        return this.request('POST', '/api/skills/upload', form, null, headers);
+    }
+    async pollAuth(requestId) {
+        // Polls the auth endpoint
+        // Python client logic: POST /api/auth/cli/poll { request_id }
+        // Returns 200 { status: 'approved', access_token... } 
+        // or 410 if expired
+        // or other code if pending
+        // NOTE: This call might 404/410/etc, so we handle it outside or rely on axios throw
+        return this.request('POST', '/api/auth/cli/poll', { request_id: requestId });
+    }
+    mapSkillInfo(data) {
+        return {
+            id: data.id || data._id || "",
+            name: data.name || "",
+            short_description: data.short_description || data.long_description || "",
+            latest_version: data.latest_version || data.version || "0.0.0",
+            author: data.author || "unknown",
+            last_updated: data.last_updated || data.updated_at || data.createdAt || "",
+            download_url: data.download_url,
+            avg_rating: data.avg_rating,
+            installs_count: data.installs_count,
+            tags: data.tags
+        };
+    }
+}
+exports.HomeSkillClient = HomeSkillClient;
+exports.client = new HomeSkillClient();

package/dist/lib/manager.js

@@ -0,0 +1,186 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.manager = exports.SkillManager = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const os_1 = __importDefault(require("os"));
+const adm_zip_1 = __importDefault(require("adm-zip"));
+const api_js_1 = require("./api.js");
+const SKILLS_DIR_NAME = 'skills';
+const METADATA_FILE = 'metadata.json';
+class SkillManager {
+    skillsDir;
+    constructor() {
+        this.skillsDir = path_1.default.join(os_1.default.homedir(), '.claude', SKILLS_DIR_NAME);
+    }
+    ensureSkillsDir() {
+        fs_extra_1.default.ensureDirSync(this.skillsDir);
+    }
+    async listLocalSkills() {
+        if (!fs_extra_1.default.existsSync(this.skillsDir))
+            return [];
+        const skills = [];
+        const items = await fs_extra_1.default.readdir(this.skillsDir);
+        for (const item of items) {
+            if (item.startsWith('.'))
+                continue;
+            const itemPath = path_1.default.join(this.skillsDir, item);
+            const stat = await fs_extra_1.default.stat(itemPath);
+            if (stat.isDirectory()) {
+                const info = await this.readSkillInfo(itemPath);
+                if (info) {
+                    skills.push(info);
+                }
+                else {
+                    skills.push({
+                        name: item,
+                        path: itemPath,
+                        version: 'unknown',
+                        description: '(No metadata)',
+                        author: 'unknown'
+                    });
+                }
+            }
+        }
+        return skills;
+    }
+    async readSkillInfo(skillPath) {
+        // 1. Try metadata.json
+        const metadataPath = path_1.default.join(skillPath, METADATA_FILE);
+        if (fs_extra_1.default.existsSync(metadataPath)) {
+            try {
+                const data = await fs_extra_1.default.readJson(metadataPath);
+                return {
+                    name: data.name || path_1.default.basename(skillPath),
+                    path: skillPath,
+                    version: data.version || '0.0.0',
+                    description: data.description || '',
+                    author: data.author || 'unknown',
+                    skill_id: data.skill_id
+                };
+            }
+            catch (e) { }
+        }
+        // 2. Try skill.md frontmatter
+        const skillMdPath = path_1.default.join(skillPath, 'skill.md');
+        if (fs_extra_1.default.existsSync(skillMdPath)) {
+            // Basic frontmatter parsing
+            const content = await fs_extra_1.default.readFile(skillMdPath, 'utf-8');
+            if (content.startsWith('---')) {
+                const parts = content.split('---');
+                if (parts.length >= 3) {
+                    const frontmatter = parts[1];
+                    const data = {};
+                    frontmatter.split('\n').forEach(line => {
+                        const [key, ...vals] = line.split(':');
+                        if (key && vals.length > 0) {
+                            data[key.trim()] = vals.join(':').trim().replace(/['"]/g, '');
+                        }
+                    });
+                    if (data.name) {
+                        return {
+                            name: data.name,
+                            path: skillPath,
+                            version: data.version || '0.0.0',
+                            description: data.description || '',
+                            author: data.author || 'unknown',
+                            skill_id: data.skill_id
+                        };
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    getSkillPath(skillName) {
+        return path_1.default.join(this.skillsDir, skillName);
+    }
+    async installSkill(skillId, name, force = false) {
+        const info = await api_js_1.client.getSkillInfo(skillId);
+        const targetName = name || info.name;
+        const targetPath = path_1.default.join(this.skillsDir, targetName);
+        if (fs_extra_1.default.existsSync(targetPath)) {
+            if (!force) {
+                throw new Error(`Skill '${targetName}' already exists. Use -f to overwrite.`);
+            }
+            // Backup
+            const backupPath = path_1.default.join(path_1.default.dirname(targetPath), `${targetName}-backup-${Date.now()}`);
+            await fs_extra_1.default.move(targetPath, backupPath);
+        }
+        // Download
+        const zipBuffer = await api_js_1.client.downloadSkill(skillId);
+        // Extract
+        const zip = new adm_zip_1.default(zipBuffer);
+        const tmpDir = path_1.default.join(os_1.default.tmpdir(), `homeskill-${Date.now()}`);
+        zip.extractAllTo(tmpDir, true);
+        // Identify nested folder
+        const files = await fs_extra_1.default.readdir(tmpDir);
+        let sourceDir = tmpDir;
+        // Smart detection: if single folder, assume it's the wrapper
+        if (files.length === 1) {
+            const possibleDir = path_1.default.join(tmpDir, files[0]);
+            if ((await fs_extra_1.default.stat(possibleDir)).isDirectory()) {
+                sourceDir = possibleDir;
+            }
+        }
+        // Move to target
+        await fs_extra_1.default.move(sourceDir, targetPath, { overwrite: true });
+        // Write metadata
+        const metadata = {
+            name: info.name,
+            version: info.latest_version,
+            description: info.short_description,
+            author: info.author,
+            skill_id: info.id,
+            installed_at: new Date().toISOString(),
+            source: 'homeskill'
+        };
+        await fs_extra_1.default.writeJson(path_1.default.join(targetPath, METADATA_FILE), metadata, { spaces: 2 });
+        // Cleanup
+        if (sourceDir !== tmpDir) {
+            await fs_extra_1.default.remove(tmpDir).catch(() => { });
+        }
+        return {
+            ...metadata,
+            path: targetPath
+        };
+    }
+    async packageSkill(skillName) {
+        const skillPath = this.getSkillPath(skillName);
+        if (!fs_extra_1.default.existsSync(skillPath)) {
+            throw new Error(`Skill '${skillName}' not found`);
+        }
+        const info = await this.readSkillInfo(skillPath);
+        if (!info) {
+            throw new Error(`Skill metadata not found in '${skillName}'`);
+        }
+        // Create zip
+        const zip = new adm_zip_1.default();
+        // Add local folder recursively, filtering out hidden files
+        const addFolder = (dir, zipPath) => {
+            const files = fs_extra_1.default.readdirSync(dir);
+            for (const file of files) {
+                if (file.startsWith('.') || file === '__pycache__' || file === 'node_modules')
+                    continue;
+                const fullPath = path_1.default.join(dir, file);
+                const stat = fs_extra_1.default.statSync(fullPath);
+                if (stat.isDirectory()) {
+                    addFolder(fullPath, path_1.default.join(zipPath, file));
+                }
+                else {
+                    zip.addLocalFile(fullPath, zipPath);
+                }
+            }
+        };
+        addFolder(skillPath, "");
+        return {
+            buffer: zip.toBuffer(),
+            info
+        };
+    }
+}
+exports.SkillManager = SkillManager;
+exports.manager = new SkillManager();

package/package.json

@@ -0,0 +1,57 @@
+{
+    "name": "homeskill",
+    "version": "1.0.0",
+    "description": "The Skill to manage Skills. Search, Install, and Manage Claude Skills with ease.",
+    "main": "dist/index.js",
+    "bin": {
+        "homeskill": "dist/index.js"
+    },
+    "type": "commonjs",
+    "scripts": {
+        "build": "tsc",
+        "prepublishOnly": "npm run build",
+        "start": "node dist/index.js",
+        "dev": "ts-node src/index.js"
+    },
+    "keywords": [
+        "homeskill",
+        "mcp",
+        "claude",
+        "level",
+        "anthropic",
+        "agent",
+        "skills",
+        "model context protocol"
+    ],
+    "author": "HomeSkill Team <support@homeskill.org> (https://homeskill.org)",
+    "license": "MIT",
+    "homepage": "https://homeskill.org",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/Start-Z-Labs/homeskill-web.git"
+    },
+    "bugs": {
+        "url": "https://github.com/Start-Z-Labs/homeskill-web/issues"
+    },
+    "engines": {
+        "node": ">=18.0.0"
+    },
+    "dependencies": {
+        "@types/uuid": "^11.0.0",
+        "adm-zip": "^0.5.10",
+        "axios": "^1.6.0",
+        "chalk": "^4.1.2",
+        "commander": "^12.0.0",
+        "form-data": "^4.0.5",
+        "fs-extra": "^11.2.0",
+        "open": "^11.0.0",
+        "uuid": "^13.0.0"
+    },
+    "devDependencies": {
+        "@types/adm-zip": "^0.5.5",
+        "@types/fs-extra": "^11.0.0",
+        "@types/node": "^20.11.0",
+        "ts-node": "^10.9.2",
+        "typescript": "^5.3.3"
+    }
+}