openclaw-skills-cli 0.1.0

package/PUBLISH-INSTRUCTIONS.md

@@ -0,0 +1,209 @@
+# 📦 Instrucciones para Publicar CLI en npm
+
+## ✅ Preparación Completada
+
+- ✅ Package renombrado a `openclaw-skills-cli` (sin scope)
+- ✅ README.md creado para página npm
+- ✅ .npmignore configurado
+- ✅ CLI compilado y listo
+- ✅ Todas las referencias actualizadas en el código
+
+---
+
+## 🚀 Pasos para Publicar (José)
+
+### **Paso 1: Crear Cuenta npm** (5 minutos)
+
+1. Ve a https://www.npmjs.com/signup
+2. Rellena el formulario:
+   - **Username:** `jotajota1302` (o el que prefieras)
+   - **Email:** Tu email
+   - **Password:** Contraseña segura
+3. Verifica tu email (te llegará un correo de confirmación)
+
+---
+
+### **Paso 2: Login desde la Terminal** (1 minuto)
+
+Abre una terminal y ejecuta:
+
+```bash
+npm login
+```
+
+Te pedirá:
+- **Username:** (el que elegiste)
+- **Password:** (tu contraseña)
+- **Email:** (tu email)
+
+**Nota:** Si te pide autenticación web, sigue el link que te muestre.
+
+---
+
+### **Paso 3: Verificar que Estás Logueado**
+
+```bash
+npm whoami
+```
+
+Debería mostrar tu username. Si muestra error, repite `npm login`.
+
+---
+
+### **Paso 4: Publicar el CLI** (30 segundos)
+
+```bash
+cd ~/Desktop/PROYECTOS/activos/openclaw-skills-registry/cli
+npm publish
+```
+
+**Resultado esperado:**
+```
++ openclaw-skills-cli@0.1.0
+```
+
+**Si sale error "name already taken":**
+```bash
+# Edita package.json y cambia el nombre
+nano package.json
+# Cambia "openclaw-skills-cli" por "openclaw-skills" o "skills-cli-openclaw"
+# Luego repite: npm publish
+```
+
+---
+
+### **Paso 5: Verificar Publicación** (1 minuto)
+
+Abre una nueva terminal (sin el proyecto) y prueba:
+
+```bash
+npx openclaw-skills-cli@latest --version
+```
+
+Debería mostrar: `0.1.0`
+
+---
+
+### **Paso 6: Test Completo**
+
+Prueba instalar una skill:
+
+```bash
+npx openclaw-skills-cli search security
+```
+
+Debería mostrar resultados de skills de seguridad.
+
+---
+
+## ✅ Después de Publicar
+
+Una vez publicado, **TODOS los comandos en /clients funcionarán:**
+
+```bash
+# Esto ya funcionará:
+npx openclaw-skills-cli install skillia/ai-governance-audit
+
+# Y esto también:
+npm i -g openclaw-skills-cli
+openclaw-skills install skill/name
+```
+
+---
+
+## 🎯 Verificación Final
+
+1. Ve a: https://www.npmjs.com/package/openclaw-skills-cli
+2. Deberías ver tu paquete publicado con README, versión, stats, etc.
+
+---
+
+## 📊 Métricas npm
+
+Después de publicar, podrás ver en npm:
+- Descargas semanales
+- Dependents (quién usa tu paquete)
+- GitHub stars
+- Versiones publicadas
+
+---
+
+## 🔄 Publicar Actualizaciones Futuras
+
+Cuando quieras publicar una nueva versión:
+
+```bash
+cd cli
+
+# Opción A: Patch (0.1.0 → 0.1.1)
+npm version patch
+
+# Opción B: Minor (0.1.0 → 0.2.0)
+npm version minor
+
+# Opción C: Major (0.1.0 → 1.0.0)
+npm version major
+
+# Publicar
+npm publish
+```
+
+---
+
+## ⚠️ Troubleshooting
+
+### Error: "You must be logged in"
+```bash
+npm logout
+npm login
+```
+
+### Error: "402 Payment Required"
+Solo para scoped packages (@org/pkg). Nosotros usamos `openclaw-skills-cli` (sin scope), así que NO deberías ver este error.
+
+### Error: "403 Forbidden"
+```bash
+# Verifica que estás logueado:
+npm whoami
+
+# Si no muestra tu usuario:
+npm login
+```
+
+### Error: "name already taken"
+Cambia el nombre en `package.json` y repite:
+```bash
+# Opciones alternativas:
+"name": "openclaw-skills"
+"name": "skills-cli-openclaw"
+"name": "openclaw-registry-cli"
+```
+
+---
+
+## 📞 Si Tienes Problemas
+
+Avísame por Telegram y te ayudo en tiempo real.
+
+---
+
+## 🎉 Resultado Esperado
+
+**Antes:**
+```bash
+$ npx openclaw-skills-cli install skill
+→ 404 Not Found
+```
+
+**Después:**
+```bash
+$ npx openclaw-skills-cli install skill
+→ ✓ Installing skill...
+```
+
+**Clientes podrán instalar skills sin problemas** ✅
+
+---
+
+**Preparado por:** JARVIS  
+**Fecha:** 2026-02-27 18:05 GMT+1

package/README.md

@@ -0,0 +1,76 @@
+# openclaw-skills-cli
+
+Official CLI for [Skillia](https://openclaw-skills-registry-dashboard.vercel.app) - The OpenClaw Skills Registry.
+
+## Installation
+
+### Quick Run (npx)
+```bash
+npx openclaw-skills-cli install namespace/skill-name
+```
+
+### Global Install
+```bash
+npm install -g openclaw-skills-cli
+openclaw-skills --help
+```
+
+## Usage
+
+### Search Skills
+```bash
+openclaw-skills search security
+```
+
+### Install a Skill
+```bash
+# Free skills
+openclaw-skills install skillia/ai-governance-audit
+
+# Paid skills (requires license token)
+openclaw-skills install --license-token <token> namespace/skill-name
+```
+
+### Publish a Skill
+
+1. Create an API token at [Skillia Account](https://openclaw-skills-registry-dashboard.vercel.app/account)
+2. Login with your token:
+```bash
+openclaw-skills login <your-api-token>
+```
+3. Publish your skill:
+```bash
+cd my-skill-folder
+openclaw-skills publish
+```
+
+## Commands
+
+- `login <token>` - Authenticate with your API token
+- `search [query]` - Search for skills in the registry
+- `install <namespace/name>` - Install a skill
+- `publish [folder]` - Publish a skill to the registry
+- `import` - Import MCP servers from Anthropic registry
+
+## Configuration
+
+The CLI stores configuration in `~/.config/openclaw-skills/config.json`.
+
+## API
+
+Default API URL: `https://openclaw-skills-registry.onrender.com`
+
+Override with `--api-url` flag:
+```bash
+openclaw-skills --api-url http://localhost:3000 search test
+```
+
+## License
+
+MIT
+
+## Links
+
+- [Skillia Marketplace](https://openclaw-skills-registry-dashboard.vercel.app)
+- [Documentation](https://openclaw-skills-registry-dashboard.vercel.app/developers)
+- [GitHub](https://github.com/jotajota1302/skills-registry)

package/dist/api/client.js

@@ -0,0 +1,115 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createToken = createToken;
+exports.listSkills = listSkills;
+exports.getSkill = getSkill;
+exports.publishSkill = publishSkill;
+exports.getInstallConfig = getInstallConfig;
+exports.getVersion = getVersion;
+exports.listVersions = listVersions;
+exports.publishVersion = publishVersion;
+exports.registerInstall = registerInstall;
+exports.triggerMcpImport = triggerMcpImport;
+exports.checkHealth = checkHealth;
+exports.getInstallPack = getInstallPack;
+exports.consumeInstallPack = consumeInstallPack;
+const axios_1 = __importDefault(require("axios"));
+const config_js_1 = require("../config.js");
+function createClient() {
+    const client = axios_1.default.create({
+        baseURL: (0, config_js_1.getApiUrl)(),
+        timeout: 15000,
+    });
+    client.interceptors.request.use((config) => {
+        const token = (0, config_js_1.getToken)();
+        if (token) {
+            config.headers.Authorization = `Bearer ${token}`;
+        }
+        return config;
+    });
+    return client;
+}
+async function createToken(clientId, secret) {
+    const client = createClient();
+    const { data } = await client.post('/v1/auth/token', { clientId, secret });
+    return data;
+}
+async function listSkills(opts) {
+    const client = createClient();
+    const params = {
+        q: opts.q,
+        keyword: opts.keyword,
+        page: opts.page,
+        limit: opts.limit,
+        sort: opts.sort,
+        type: opts.type,
+        tier: opts.tier,
+    };
+    if (opts.certified) {
+        params.certified = 'true';
+    }
+    const { data } = await client.get('/v1/skills', { params });
+    return data;
+}
+async function getSkill(namespace, name) {
+    const client = createClient();
+    const { data } = await client.get(`/v1/skills/${namespace}/${name}`);
+    return data;
+}
+async function publishSkill(skillData) {
+    const client = createClient();
+    const { data } = await client.post('/v1/skills', skillData);
+    return data;
+}
+async function getInstallConfig(namespace, name) {
+    const client = createClient();
+    const { data } = await client.get(`/v1/skills/${namespace}/${name}/install-config`);
+    return data;
+}
+async function getVersion(namespace, name, version) {
+    const client = createClient();
+    const { data } = await client.get(`/v1/skills/${namespace}/${name}/${version}`);
+    return data;
+}
+async function listVersions(namespace, name) {
+    const client = createClient();
+    const { data } = await client.get(`/v1/skills/${namespace}/${name}/versions`);
+    return data;
+}
+async function publishVersion(namespace, name, versionData) {
+    const client = createClient();
+    const { data } = await client.post(`/v1/skills/${namespace}/${name}/versions`, versionData);
+    return data;
+}
+async function registerInstall(namespace, name, version) {
+    const client = createClient();
+    const { data } = await client.post(`/v1/skills/${namespace}/${name}/installs`, version ? { version } : {});
+    return data;
+}
+async function triggerMcpImport(opts) {
+    const client = createClient();
+    const params = {
+        dryRun: opts.dryRun ? 'true' : undefined,
+        limit: opts.limit,
+    };
+    const { data } = await client.post('/v1/admin/import/mcp', undefined, { params });
+    return data;
+}
+async function checkHealth() {
+    const client = createClient();
+    const { data } = await client.get('/v1/health');
+    return data;
+}
+async function getInstallPack(token) {
+    const client = createClient();
+    const { data } = await client.get(`/v1/install-packs/${token}`);
+    return data;
+}
+async function consumeInstallPack(token) {
+    const client = createClient();
+    const { data } = await client.post(`/v1/install-packs/${token}/consume`);
+    return data;
+}

package/dist/cli.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const config_js_1 = require("./config.js");
+const login_js_1 = require("./commands/login.js");
+const search_js_1 = require("./commands/search.js");
+const install_js_1 = require("./commands/install.js");
+const publish_js_1 = require("./commands/publish.js");
+const import_js_1 = require("./commands/import.js");
+const program = new commander_1.Command();
+program
+    .name('openclaw-skills')
+    .description('CLI del OpenClaw Skills Registry')
+    .version('0.1.0')
+    .option('--api-url <url>', 'URL de la API del registry')
+    .hook('preAction', (thisCommand) => {
+    const opts = thisCommand.opts();
+    if (opts.apiUrl) {
+        (0, config_js_1.setApiUrl)(opts.apiUrl);
+    }
+});
+program.addCommand(login_js_1.loginCommand);
+program.addCommand(search_js_1.searchCommand);
+program.addCommand(install_js_1.installCommand);
+program.addCommand(publish_js_1.publishCommand);
+program.addCommand(import_js_1.importCommand);
+program.parse();

package/dist/commands/import.js

@@ -0,0 +1,169 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importCommand = void 0;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const axios_1 = __importDefault(require("axios"));
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const client_js_1 = require("../api/client.js");
+const errors_js_1 = require("../utils/errors.js");
+const config_js_1 = require("../config.js");
+const EXCLUDED_DIRS = new Set(['node_modules', '.git', '.next', 'dist', 'build', 'coverage']);
+function readFilesRecursive(dir, baseDir) {
+    const files = {};
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (EXCLUDED_DIRS.has(entry.name))
+            continue;
+        if (entry.name.startsWith('.env'))
+            continue;
+        const fullPath = path.join(dir, entry.name);
+        const relativePath = path.relative(baseDir, fullPath).replace(/\\/g, '/');
+        if (entry.isDirectory()) {
+            Object.assign(files, readFilesRecursive(fullPath, baseDir));
+            continue;
+        }
+        try {
+            files[relativePath] = fs.readFileSync(fullPath, 'utf-8');
+        }
+        catch {
+            // ignore binary/unreadable files
+        }
+    }
+    return files;
+}
+const mcpImportCommand = new commander_1.Command('mcp')
+    .description('Importar servidores MCP desde el registry oficial')
+    .option('--dry-run', 'Simula import sin escribir en DB')
+    .option('--limit <n>', 'Limita número de registros procesados')
+    .action(async (opts) => {
+    const spinner = (0, ora_1.default)('Importando MCP registry...').start();
+    try {
+        const result = await (0, client_js_1.triggerMcpImport)({
+            dryRun: !!opts.dryRun,
+            limit: opts.limit ? Number(opts.limit) : undefined,
+        });
+        spinner.succeed('Import completado');
+        const stats = result?.result || {};
+        console.log(chalk_1.default.bold('\nMCP Import Result'));
+        console.log(`dryRun: ${result?.dryRun ? 'true' : 'false'}`);
+        console.log(`scanned: ${stats.scanned ?? 0}`);
+        console.log(`imported: ${stats.imported ?? 0}`);
+        console.log(`updated: ${stats.updated ?? 0}`);
+        console.log(`skipped: ${stats.skipped ?? 0}`);
+    }
+    catch (error) {
+        spinner.fail('Error importando MCP registry');
+        (0, errors_js_1.handleApiError)(error);
+    }
+});
+const domainImportCommand = new commander_1.Command('domain')
+    .description('Publicar una domain skill local en el registry (no interactivo)')
+    .argument('<folder>', 'Carpeta local de la skill')
+    .option('--namespace <namespace>', 'Override namespace')
+    .option('--name <name>', 'Override nombre de skill')
+    .option('--version <version>', 'Override versión')
+    .option('--tier <tier>', 'Tier: free|pro|enterprise')
+    .option('--description <description>', 'Override descripción')
+    .action(async (folder, opts) => {
+    const token = (0, config_js_1.getToken)();
+    if (!token) {
+        console.log(chalk_1.default.red("Ejecuta 'openclaw-skills login <token>' primero"));
+        process.exit(1);
+    }
+    try {
+        const resolvedFolder = path.resolve(folder);
+        const skillJsonPath = path.join(resolvedFolder, 'skill.json');
+        const skillMdPath = path.join(resolvedFolder, 'SKILL.md');
+        if (!fs.existsSync(skillMdPath)) {
+            throw new Error(`No se encontró SKILL.md en ${resolvedFolder}`);
+        }
+        if (!fs.existsSync(skillJsonPath)) {
+            throw new Error(`No se encontró skill.json en ${resolvedFolder}`);
+        }
+        const metadata = JSON.parse(fs.readFileSync(skillJsonPath, 'utf-8'));
+        const namespace = opts.namespace || metadata.namespace;
+        const name = opts.name || metadata.name;
+        const version = opts.version || metadata.version;
+        const description = opts.description || metadata.description;
+        const tier = opts.tier || metadata.tier || 'free';
+        const keywords = metadata.keywords || [];
+        const type = (metadata.type || 'DOMAIN').toUpperCase();
+        if (!namespace || !name || !description || !version) {
+            throw new Error('skill.json requiere namespace, name, description y version');
+        }
+        if (type !== 'DOMAIN') {
+            throw new Error(`Este comando solo publica DOMAIN. Recibido: ${type}`);
+        }
+        const files = readFilesRecursive(resolvedFolder, resolvedFolder);
+        const spinner = (0, ora_1.default)(`Publicando domain skill ${chalk_1.default.cyan(namespace)}/${chalk_1.default.bold(name)}@${version}...`).start();
+        try {
+            await (0, client_js_1.publishSkill)({
+                namespace,
+                name,
+                description,
+                keywords,
+                files,
+                version,
+                type,
+                tier,
+            });
+            spinner.succeed(chalk_1.default.green(`Domain skill publicada: ${namespace}/${name}@${version}`));
+        }
+        catch (error) {
+            if (axios_1.default.isAxiosError(error) && error.response?.status === 409) {
+                await (0, client_js_1.publishVersion)(namespace, name, { version, files, changelog: 'Imported from local folder via CLI import domain' });
+                spinner.succeed(chalk_1.default.green(`Versión publicada sobre skill existente: ${namespace}/${name}@${version}`));
+            }
+            else {
+                spinner.fail('Error publicando domain skill');
+                throw error;
+            }
+        }
+    }
+    catch (error) {
+        (0, errors_js_1.handleApiError)(error);
+    }
+});
+exports.importCommand = new commander_1.Command('import')
+    .description('Comandos de importación')
+    .addCommand(mcpImportCommand)
+    .addCommand(domainImportCommand);

package/dist/commands/install.js

@@ -0,0 +1,272 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installCommand = void 0;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const os = __importStar(require("node:os"));
+const prompts_1 = require("@inquirer/prompts");
+const client_js_1 = require("../api/client.js");
+const errors_js_1 = require("../utils/errors.js");
+function parseSkillArg(arg) {
+    const atIndex = arg.lastIndexOf('@');
+    let fullName;
+    let version;
+    if (atIndex > 0) {
+        fullName = arg.substring(0, atIndex);
+        version = arg.substring(atIndex + 1);
+    }
+    else {
+        fullName = arg;
+    }
+    const slashIndex = fullName.lastIndexOf('/');
+    if (slashIndex === -1) {
+        throw new Error(`Formato inválido. Usa: namespace/name[@version]`);
+    }
+    return {
+        namespace: fullName.substring(0, slashIndex),
+        name: fullName.substring(slashIndex + 1),
+        version,
+    };
+}
+function detectMcpClients() {
+    const clients = [];
+    const home = os.homedir();
+    if (fs.existsSync(path.join(home, '.claude')))
+        clients.push('claude');
+    if (fs.existsSync(path.join(home, '.codex')))
+        clients.push('codex');
+    if (fs.existsSync(path.join(home, '.cursor')))
+        clients.push('cursor');
+    return clients;
+}
+const MCP_CONFIG_PATHS = {
+    claude: '.claude/mcp.json',
+    codex: '.codex/mcp_config.json',
+    cursor: '.cursor/mcp.json',
+};
+function writeMcpEntry(client, skillName, mcpConfig) {
+    const home = os.homedir();
+    const configRelPath = MCP_CONFIG_PATHS[client];
+    if (!configRelPath)
+        return;
+    const configPath = path.join(home, configRelPath);
+    let existing = {};
+    if (fs.existsSync(configPath)) {
+        try {
+            existing = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        }
+        catch {
+            existing = {};
+        }
+    }
+    else {
+        fs.mkdirSync(path.dirname(configPath), { recursive: true });
+    }
+    const serversKey = 'mcpServers';
+    if (!existing[serversKey] || typeof existing[serversKey] !== 'object') {
+        existing[serversKey] = {};
+    }
+    const entry = {};
+    if (mcpConfig.url) {
+        entry.url = mcpConfig.url;
+    }
+    if (mcpConfig.command) {
+        entry.command = mcpConfig.command;
+    }
+    if (mcpConfig.args) {
+        entry.args = mcpConfig.args;
+    }
+    if (mcpConfig.env) {
+        entry.env = mcpConfig.env;
+    }
+    existing[serversKey][skillName] = entry;
+    fs.writeFileSync(configPath, JSON.stringify(existing, null, 2), 'utf-8');
+}
+async function installToolOrDomain(namespace, name, targetVersion, installConfig) {
+    // Check subscription requirement for DOMAIN
+    if (installConfig.type === 'DOMAIN' && installConfig.requiresSubscription) {
+        console.log(chalk_1.default.yellow('\n⚠️  Este skill requiere suscripción Pro. Contacta con registry para activarla.'));
+    }
+    const installDir = path.join(os.homedir(), '.openclaw', 'skills', namespace, name);
+    if (fs.existsSync(installDir)) {
+        const overwrite = await (0, prompts_1.confirm)({
+            message: `${namespace}/${name} ya está instalado. ¿Sobreescribir?`,
+            default: false,
+        });
+        if (!overwrite) {
+            console.log(chalk_1.default.yellow('Instalación cancelada'));
+            return;
+        }
+        fs.rmSync(installDir, { recursive: true, force: true });
+    }
+    const spinner = (0, ora_1.default)(`Instalando ${chalk_1.default.cyan(namespace)}/${chalk_1.default.bold(name)}${chalk_1.default.gray('@' + targetVersion)}...`).start();
+    // Try direct download from filesUrl first, fallback to API
+    const installConfigData = await (0, client_js_1.getInstallConfig)(namespace, name);
+    let files;
+    if ('filesUrl' in installConfigData && installConfigData.filesUrl) {
+        // Download from Supabase Storage
+        const response = await fetch(installConfigData.filesUrl);
+        if (response.ok) {
+            files = await response.json();
+        }
+        else {
+            // Fallback to version API
+            const versionData = await (0, client_js_1.getVersion)(namespace, name, targetVersion);
+            files = versionData.files || {};
+        }
+    }
+    else {
+        const versionData = await (0, client_js_1.getVersion)(namespace, name, targetVersion);
+        files = versionData.files || {};
+    }
+    for (const [filePath, content] of Object.entries(files)) {
+        const fullPath = path.join(installDir, filePath);
+        fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+        fs.writeFileSync(fullPath, content, 'utf-8');
+    }
+    try {
+        await (0, client_js_1.registerInstall)(namespace, name, targetVersion);
+    }
+    catch {
+        // Install tracking is best-effort
+    }
+    spinner.succeed(chalk_1.default.green(`Instalado en ~/.openclaw/skills/${namespace}/${name}/`));
+}
+async function installMcpServer(name, mcpConfig, targets, targetFlag) {
+    let selectedClients;
+    if (targetFlag === 'all') {
+        selectedClients = detectMcpClients();
+        if (selectedClients.length === 0) {
+            console.log(chalk_1.default.red('No se detectaron clientes MCP instalados (claude, codex, cursor)'));
+            return;
+        }
+    }
+    else if (targetFlag) {
+        selectedClients = [targetFlag];
+    }
+    else {
+        // Auto-detect and ask
+        const available = detectMcpClients();
+        if (available.length === 0) {
+            console.log(chalk_1.default.red('No se detectaron clientes MCP instalados (claude, codex, cursor)'));
+            return;
+        }
+        if (available.length === 1) {
+            selectedClients = available;
+        }
+        else {
+            const chosen = await (0, prompts_1.select)({
+                message: '¿En qué cliente MCP quieres instalar?',
+                choices: [
+                    ...available.map((c) => ({ name: c, value: c })),
+                    { name: 'Todos', value: 'all' },
+                ],
+            });
+            selectedClients = chosen === 'all' ? available : [chosen];
+        }
+    }
+    const spinner = (0, ora_1.default)(`Configurando MCP server ${chalk_1.default.bold(name)}...`).start();
+    for (const client of selectedClients) {
+        writeMcpEntry(client, name, mcpConfig);
+    }
+    spinner.succeed(chalk_1.default.green(`MCP server ${chalk_1.default.bold(name)} configurado en: ${selectedClients.join(', ')}`));
+}
+exports.installCommand = new commander_1.Command('install')
+    .description('Instalar un skill desde el registry')
+    .argument('[skill]', 'Skill a instalar (namespace/name[@version])')
+    .option('--target <target>', 'Cliente MCP objetivo: claude, codex, cursor, all')
+    .option('--license-token <token>', 'Token de licencia del install pack')
+    .action(async (skillArg, opts) => {
+    try {
+        let namespace;
+        let name;
+        let version;
+        if (opts.licenseToken) {
+            const consumed = await (0, client_js_1.consumeInstallPack)(opts.licenseToken);
+            if (!consumed.ok || !consumed.install) {
+                throw new Error(consumed.error || 'No se pudo validar el license token');
+            }
+            namespace = consumed.install.namespace;
+            name = consumed.install.name;
+            version = consumed.install.version || undefined;
+        }
+        else {
+            if (!skillArg) {
+                throw new Error('Debes indicar un skill o usar --license-token');
+            }
+            const parsed = parseSkillArg(skillArg);
+            namespace = parsed.namespace;
+            name = parsed.name;
+            version = parsed.version;
+        }
+        // Resolve version
+        let targetVersion = version;
+        if (!targetVersion) {
+            const skill = await (0, client_js_1.getSkill)(namespace, name);
+            const latest = skill.versions?.[0];
+            if (!latest) {
+                console.log(chalk_1.default.red('Este skill no tiene versiones publicadas'));
+                return;
+            }
+            targetVersion = latest.version;
+        }
+        // Get install config to determine type
+        const installConfig = await (0, client_js_1.getInstallConfig)(namespace, name);
+        if (installConfig.type === 'MCP_SERVER') {
+            await installMcpServer(name, installConfig.mcpConfig, installConfig.targets, opts.target);
+        }
+        else {
+            // TOOL or DOMAIN — file-based installation
+            await installToolOrDomain(namespace, name, targetVersion, installConfig);
+        }
+        // Register install (best-effort)
+        try {
+            await (0, client_js_1.registerInstall)(namespace, name, targetVersion);
+        }
+        catch {
+            // best-effort
+        }
+    }
+    catch (error) {
+        (0, errors_js_1.handleApiError)(error);
+    }
+});

package/dist/commands/login.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loginCommand = void 0;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const config_js_1 = require("../config.js");
+const client_js_1 = require("../api/client.js");
+const errors_js_1 = require("../utils/errors.js");
+exports.loginCommand = new commander_1.Command('login')
+    .description('Guardar token de autenticación')
+    .argument('<token>', 'Token de acceso')
+    .action(async (token) => {
+    const spinner = (0, ora_1.default)('Verificando token...').start();
+    try {
+        await (0, client_js_1.checkHealth)();
+        (0, config_js_1.setToken)(token);
+        spinner.succeed(chalk_1.default.green('Token guardado correctamente'));
+    }
+    catch (error) {
+        spinner.fail('Error al verificar conexión con la API');
+        (0, errors_js_1.handleApiError)(error);
+    }
+});

package/dist/commands/publish.js

@@ -0,0 +1,222 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.publishCommand = void 0;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const prompts_1 = require("@inquirer/prompts");
+const config_js_1 = require("../config.js");
+const client_js_1 = require("../api/client.js");
+const errors_js_1 = require("../utils/errors.js");
+const axios_1 = __importDefault(require("axios"));
+const EXCLUDED_DIRS = ['node_modules', '.git', '.env', 'dist', '__pycache__'];
+function readFilesRecursive(dir, baseDir) {
+    const files = {};
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (EXCLUDED_DIRS.includes(entry.name))
+            continue;
+        if (entry.name.startsWith('.env'))
+            continue;
+        const fullPath = path.join(dir, entry.name);
+        const relativePath = path.relative(baseDir, fullPath);
+        if (entry.isDirectory()) {
+            Object.assign(files, readFilesRecursive(fullPath, baseDir));
+        }
+        else {
+            try {
+                files[relativePath] = fs.readFileSync(fullPath, 'utf-8');
+            }
+            catch {
+                // Skip binary/unreadable files
+            }
+        }
+    }
+    return files;
+}
+exports.publishCommand = new commander_1.Command('publish')
+    .description('Publicar un skill en el registry')
+    .argument('[folder]', 'Carpeta del skill', './')
+    .action(async (folder) => {
+    try {
+        const token = (0, config_js_1.getToken)();
+        if (!token) {
+            console.log(chalk_1.default.red("Ejecuta 'openclaw-skills login <token>' primero"));
+            process.exit(1);
+        }
+        const resolvedFolder = path.resolve(folder);
+        const skillMdPath = path.join(resolvedFolder, 'SKILL.md');
+        if (!fs.existsSync(skillMdPath)) {
+            console.log(chalk_1.default.red('No se encontró SKILL.md en ' + resolvedFolder));
+            console.log(chalk_1.default.yellow('SKILL.md es obligatorio para publicar un skill'));
+            process.exit(1);
+        }
+        // Try to read metadata from skill.json or package.json
+        let metadata = {};
+        const skillJsonPath = path.join(resolvedFolder, 'skill.json');
+        const packageJsonPath = path.join(resolvedFolder, 'package.json');
+        if (fs.existsSync(skillJsonPath)) {
+            metadata = JSON.parse(fs.readFileSync(skillJsonPath, 'utf-8'));
+        }
+        else if (fs.existsSync(packageJsonPath)) {
+            metadata = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+        }
+        const folderName = path.basename(resolvedFolder);
+        // Skill type selection
+        const skillType = await (0, prompts_1.select)({
+            message: 'Tipo de skill:',
+            choices: [
+                { name: '🔧 Tool integration', value: 'TOOL' },
+                { name: '⚡ MCP Server', value: 'MCP_SERVER' },
+                { name: '🧠 Domain skill', value: 'DOMAIN' },
+            ],
+            default: metadata.type || 'TOOL',
+        });
+        // MCP config if MCP_SERVER
+        let mcpConfig;
+        if (skillType === 'MCP_SERVER') {
+            console.log(chalk_1.default.cyan('\nConfiguración MCP Server:'));
+            const transport = await (0, prompts_1.select)({
+                message: 'Tipo de transporte:',
+                choices: [
+                    { name: 'HTTP (URL remota)', value: 'http' },
+                    { name: 'stdio (comando local)', value: 'stdio' },
+                ],
+            });
+            mcpConfig = { transport };
+            if (transport === 'http') {
+                const url = await (0, prompts_1.input)({
+                    message: 'URL del MCP server:',
+                    validate: (v) => (v.startsWith('http') ? true : 'Debe ser una URL válida'),
+                });
+                mcpConfig.url = url;
+            }
+            else {
+                const command = await (0, prompts_1.input)({
+                    message: 'Comando a ejecutar:',
+                    validate: (v) => (v.length > 0 ? true : 'El comando es obligatorio'),
+                });
+                mcpConfig.command = command;
+                const argsInput = await (0, prompts_1.input)({
+                    message: 'Argumentos (separados por espacio, vacío para ninguno):',
+                });
+                if (argsInput.trim()) {
+                    mcpConfig.args = argsInput.trim().split(/\s+/);
+                }
+            }
+        }
+        // Tier selection
+        const tier = await (0, prompts_1.select)({
+            message: 'Tier:',
+            choices: [
+                { name: 'Free', value: 'free' },
+                { name: 'Pro', value: 'pro' },
+                { name: 'Enterprise', value: 'enterprise' },
+            ],
+            default: metadata.tier || 'free',
+        });
+        const namespace = await (0, prompts_1.input)({
+            message: 'Namespace:',
+            default: metadata.namespace || `io.github.${process.env.USER || 'user'}`,
+        });
+        const name = await (0, prompts_1.input)({
+            message: 'Nombre del skill:',
+            default: metadata.name || folderName,
+        });
+        const description = await (0, prompts_1.input)({
+            message: 'Descripción:',
+            default: metadata.description || '',
+        });
+        const version = await (0, prompts_1.input)({
+            message: 'Versión:',
+            default: metadata.version || '1.0.0',
+        });
+        const keywordsInput = await (0, prompts_1.input)({
+            message: 'Keywords (separadas por coma):',
+            default: Array.isArray(metadata.keywords)
+                ? metadata.keywords.join(', ')
+                : '',
+        });
+        const keywords = keywordsInput
+            .split(',')
+            .map((k) => k.trim())
+            .filter(Boolean);
+        const spinner = (0, ora_1.default)(`Publicando ${chalk_1.default.bold(name)}${chalk_1.default.gray('@' + version)}...`).start();
+        const files = readFilesRecursive(resolvedFolder, resolvedFolder);
+        try {
+            await (0, client_js_1.publishSkill)({
+                namespace,
+                name,
+                description,
+                keywords,
+                files,
+                version,
+                type: skillType,
+                mcpConfig,
+                tier,
+            });
+            spinner.succeed(chalk_1.default.green(`Skill publicado: ${namespace}/${name}`));
+        }
+        catch (error) {
+            if (axios_1.default.isAxiosError(error) && error.response?.status === 409) {
+                spinner.warn(chalk_1.default.yellow(`${namespace}/${name} ya existe en el registry`));
+                const publishNew = await (0, prompts_1.confirm)({
+                    message: `¿Publicar nueva versión ${version}?`,
+                    default: true,
+                });
+                if (!publishNew) {
+                    console.log(chalk_1.default.yellow('Publicación cancelada'));
+                    return;
+                }
+                const versionSpinner = (0, ora_1.default)(`Publicando versión ${version}...`).start();
+                await (0, client_js_1.publishVersion)(namespace, name, { version, files });
+                versionSpinner.succeed(chalk_1.default.green(`Versión ${version} publicada: ${namespace}/${name}`));
+            }
+            else {
+                spinner.fail('Error al publicar');
+                throw error;
+            }
+        }
+    }
+    catch (error) {
+        (0, errors_js_1.handleApiError)(error);
+    }
+});

package/dist/commands/search.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchCommand = void 0;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const client_js_1 = require("../api/client.js");
+const errors_js_1 = require("../utils/errors.js");
+const TYPE_EMOJI = {
+    TOOL: '🔧',
+    MCP_SERVER: '⚡',
+    DOMAIN: '🧠',
+};
+exports.searchCommand = new commander_1.Command('search')
+    .description('Buscar skills en el registry')
+    .argument('[query]', 'Término de búsqueda')
+    .option('--keyword <kw>', 'Filtrar por keyword')
+    .option('--sort <sort>', 'Ordenar por: installs, recent, name', 'recent')
+    .option('--limit <n>', 'Número de resultados', '10')
+    .option('--type <type>', 'Filtrar por tipo: TOOL, MCP_SERVER, DOMAIN')
+    .option('--certified', 'Mostrar solo skills certificados')
+    .action(async (query, opts) => {
+    const spinner = (0, ora_1.default)('Buscando skills...').start();
+    try {
+        const result = await (0, client_js_1.listSkills)({
+            q: query,
+            keyword: opts.keyword,
+            sort: opts.sort,
+            limit: parseInt(opts.limit, 10),
+            type: opts.type,
+            certified: opts.certified || false,
+        });
+        spinner.stop();
+        const skills = result.data;
+        if (!skills || skills.length === 0) {
+            console.log(chalk_1.default.yellow('No se encontraron skills para esa búsqueda'));
+            return;
+        }
+        console.log(`\n📦 ${chalk_1.default.bold(skills.length)} skills encontrados\n`);
+        for (const skill of skills) {
+            const latestVersion = skill.versions?.[0];
+            const version = latestVersion?.version || 'N/A';
+            const keywords = skill.keywords || [];
+            const skillType = skill.type || 'TOOL';
+            const emoji = TYPE_EMOJI[skillType] || '📦';
+            const tier = skill.tier || 'free';
+            let tierBadge = '';
+            if (tier === 'pro') {
+                tierBadge = chalk_1.default.yellow(' [PRO]');
+            }
+            else if (tier === 'enterprise') {
+                tierBadge = chalk_1.default.yellow(' [ENTERPRISE]');
+            }
+            const certBadge = skill.certified ? chalk_1.default.green(' ✓ certified') : '';
+            console.log(`  ${emoji} ${chalk_1.default.cyan(skill.namespace)}/${chalk_1.default.bold(skill.name)}${chalk_1.default.gray('@' + version)}${tierBadge}${certBadge}`);
+            console.log(`     ${skill.description || 'Sin descripción'}`);
+            if (keywords.length > 0) {
+                console.log(`     Keywords: ${chalk_1.default.yellow(keywords.join(', '))}`);
+            }
+            console.log(`     Installs: ${skill.totalInstalls ?? skill.installCount ?? 0}`);
+            console.log();
+        }
+    }
+    catch (error) {
+        spinner.fail('Error al buscar skills');
+        (0, errors_js_1.handleApiError)(error);
+    }
+});

package/dist/config.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getToken = getToken;
+exports.setToken = setToken;
+exports.getApiUrl = getApiUrl;
+exports.setApiUrl = setApiUrl;
+const conf_1 = __importDefault(require("conf"));
+const config = new conf_1.default({
+    projectName: 'openclaw-skills',
+});
+function getToken() {
+    return config.get('token');
+}
+function setToken(token) {
+    config.set('token', token);
+}
+function getApiUrl() {
+    const envUrl = process.env.SKILLS_REGISTRY_URL;
+    if (envUrl)
+        return envUrl;
+    return config.get('apiUrl') || 'http://localhost:3000';
+}
+function setApiUrl(url) {
+    config.set('apiUrl', url);
+}

package/dist/utils/errors.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleApiError = handleApiError;
+const chalk_1 = __importDefault(require("chalk"));
+const axios_1 = __importDefault(require("axios"));
+function handleApiError(error) {
+    if (axios_1.default.isAxiosError(error)) {
+        const status = error.response?.status;
+        const message = error.response?.data?.error || error.response?.data?.message;
+        if (status === 401) {
+            console.log(chalk_1.default.red('Token inválido o expirado. Ejecuta login de nuevo.'));
+        }
+        else if (status === 404) {
+            console.log(chalk_1.default.red('Skill no encontrado'));
+        }
+        else if (status === 409) {
+            console.log(chalk_1.default.red(message || 'Conflicto: el recurso ya existe'));
+        }
+        else if (error.code === 'ECONNREFUSED') {
+            console.log(chalk_1.default.red('No se pudo conectar con la API. ¿Está corriendo el servidor?'));
+        }
+        else {
+            console.log(chalk_1.default.red(message || `Error del servidor (${status || 'desconocido'})`));
+        }
+    }
+    else if (error instanceof Error) {
+        if (error.code === 'ECONNREFUSED') {
+            console.log(chalk_1.default.red('No se pudo conectar con la API. ¿Está corriendo el servidor?'));
+        }
+        else {
+            console.log(chalk_1.default.red(error.message));
+        }
+    }
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "openclaw-skills-cli",
+  "version": "0.1.0",
+  "description": "CLI tool for OpenClaw Skills Registry",
+  "main": "dist/cli.js",
+  "bin": {
+    "openclaw-skills": "./dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/cli.ts",
+    "test": "jest",
+    "lint": "eslint src --ext .ts"
+  },
+  "keywords": [
+    "openclaw",
+    "skills",
+    "cli",
+    "registry"
+  ],
+  "author": "OpenClaw Team",
+  "license": "MIT",
+  "dependencies": {
+    "@inquirer/prompts": "^8.2.1",
+    "ajv": "^8.12.0",
+    "axios": "^1.6.7",
+    "chalk": "^5.3.0",
+    "cli-progress": "^3.12.0",
+    "commander": "^12.0.0",
+    "conf": "^12.0.0",
+    "inquirer": "^9.2.15",
+    "marked": "^12.0.0",
+    "ora": "^8.0.1"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^9.0.7",
+    "@types/node": "^20.11.20",
+    "@typescript-eslint/eslint-plugin": "^7.0.2",
+    "@typescript-eslint/parser": "^7.0.2",
+    "eslint": "^8.56.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2",
+    "tsx": "^4.7.1",
+    "typescript": "^5.3.3"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}