alora-mcp 0.1.0

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "alora-mcp",
+  "version": "0.1.0",
+  "description": "Servidor MCP de Alora — Claude Code, Codex, Cursor y cualquier cliente MCP",
+  "type": "module",
+  "bin": {
+    "alora-mcp": "src/index.js"
+  },
+  "dependencies": {
+    "alora-sdk": "^0.1.0",
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "tar": "^7.4.3",
+    "zod": "^3.24.0"
+  },
+  "license": "MIT",
+  "homepage": "https://alora.build",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/santideosdeman/alora.git"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "mcp",
+    "alora",
+    "deploy",
+    "claude",
+    "codex"
+  ],
+  "files": [
+    "src"
+  ]
+}

package/src/index.js

@@ -0,0 +1,183 @@
+#!/usr/bin/env node
+// Servidor MCP de Alora. Mismas capacidades que el CLI, expuestas como tools
+// para Claude Code, Codex, Cursor o cualquier cliente MCP.
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { readFileSync, rmSync } from 'node:fs';
+import { homedir, tmpdir } from 'node:os';
+import path from 'node:path';
+import * as tar from 'tar';
+import { AloraClient, AloraError } from 'alora-sdk';
+
+const CONFIG_FILE = path.join(process.env.ALORA_HOME || path.join(homedir(), '.alora'), 'config.json');
+
+function client() {
+  let cfg = {};
+  try { cfg = JSON.parse(readFileSync(CONFIG_FILE, 'utf8')); } catch {}
+  return new AloraClient({ api: cfg.api || 'https://api.alora.build', token: cfg.token });
+}
+
+const server = new McpServer({ name: 'alora', version: '0.1.0' });
+
+const ok = (data) => ({ content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] });
+const asError = (e) => ({
+  isError: true,
+  content: [{
+    type: 'text',
+    text: JSON.stringify(
+      e instanceof AloraError
+        ? { error: e.code, message: e.message, fix: e.fix }
+        : { error: 'unknown', message: e.message, fix: 'Verificá que el servidor de Alora esté corriendo y que hayas hecho alora connect.' },
+      null, 2
+    ),
+  }],
+});
+
+const wrap = (fn) => async (args) => {
+  try { return ok(await fn(args)); } catch (e) { return asError(e); }
+};
+
+server.registerTool('whoami', {
+  description: 'Identidad de este agente y su workspace en Alora.',
+  inputSchema: {},
+}, wrap(() => client().whoami()));
+
+server.registerTool('list_projects', {
+  description: 'Lista los proyectos del workspace con URL, versión activa y estado.',
+  inputSchema: {},
+}, wrap(() => client().listProjects()));
+
+server.registerTool('create_project', {
+  description: 'Crea un proyecto nuevo (una app con su URL propia). El nombre: minúsculas, números y guiones.',
+  inputSchema: { name: z.string().describe('Nombre del proyecto, ej: "mi-app"') },
+}, wrap(({ name }) => client().createProject(name)));
+
+server.registerTool('deploy', {
+  description: 'Despliega un directorio local como nueva versión del proyecto. Detecta el runtime solo (Node, Python, estático). Devuelve la URL.',
+  inputSchema: {
+    project: z.string().describe('Nombre del proyecto'),
+    dir: z.string().describe('Ruta absoluta del directorio a desplegar'),
+    message: z.string().optional().describe('Mensaje corto describiendo el cambio'),
+  },
+}, wrap(async ({ project, dir, message }) => {
+  const tmpFile = path.join(tmpdir(), `alora-mcp-${Date.now()}.tgz`);
+  await tar.create(
+    {
+      gzip: true, file: tmpFile, cwd: dir,
+      filter: (p) => !p.split(path.sep).some((seg) => ['node_modules', '.git', 'data', '.DS_Store'].includes(seg)),
+    },
+    ['.']
+  );
+  const buffer = readFileSync(tmpFile);
+  rmSync(tmpFile, { force: true });
+  return client().deploy(project, buffer, { message });
+}));
+
+server.registerTool('project_status', {
+  description: 'Estado de un proyecto: versión activa, si está corriendo, URL.',
+  inputSchema: { project: z.string() },
+}, wrap(({ project }) => client().status(project)));
+
+server.registerTool('logs', {
+  description: 'Últimas líneas de log del proyecto (deploys, runtime y salida de la app). Usalo para debuggear tus propios deploys.',
+  inputSchema: {
+    project: z.string(),
+    lines: z.number().optional().describe('Cantidad de líneas, default 100'),
+  },
+}, wrap(({ project, lines }) => client().logs(project, { lines })));
+
+server.registerTool('list_versions', {
+  description: 'Historial de versiones del proyecto, con autor y mensaje.',
+  inputSchema: { project: z.string() },
+}, wrap(({ project }) => client().listVersions(project)));
+
+server.registerTool('rollback', {
+  description: 'Vuelve el proyecto a una versión anterior. El rollback también queda como historial.',
+  inputSchema: {
+    project: z.string(),
+    version: z.number().describe('Número de versión, ej: 3'),
+  },
+}, wrap(({ project, version }) => client().rollback(project, version)));
+
+server.registerTool('share', {
+  description: 'Invita personas a un proyecto por email, con rol. Nacen privados: solo los miembros pueden entrar (login puesto por Alora, la app no necesita código de auth). La app recibe x-alora-user-email / -name / -role en cada request.',
+  inputSchema: {
+    project: z.string(),
+    emails: z.array(z.string()).describe('Emails a invitar'),
+    role: z.enum(['admin', 'user', 'viewer']).optional().describe('Default: user'),
+  },
+}, wrap(({ project, emails, role }) => client().share(project, emails, role || 'user')));
+
+server.registerTool('list_members', {
+  description: 'Quién tiene acceso a un proyecto: dueño, miembros con rol y última visita, y visibilidad.',
+  inputSchema: { project: z.string() },
+}, wrap(({ project }) => client().listMembers(project)));
+
+server.registerTool('revoke_access', {
+  description: 'Le saca el acceso a una persona al instante.',
+  inputSchema: { project: z.string(), email: z.string() },
+}, wrap(({ project, email }) => client().revokeAccess(project, email)));
+
+server.registerTool('set_visibility', {
+  description: 'Cambia la visibilidad del proyecto: "private" (solo miembros, con login) o "public" (cualquiera con el link, sin login).',
+  inputSchema: { project: z.string(), visibility: z.enum(['private', 'public']) },
+}, wrap(({ project, visibility }) => client().setVisibility(project, visibility)));
+
+server.registerTool('analytics_summary', {
+  description: 'El pulso del proyecto: requests, usuarios activos, errores 5xx, rutas más usadas y serie por día. Usalo para saber qué partes de la app se usan (y cuáles no) antes de iterar.',
+  inputSchema: { project: z.string(), period: z.enum(['24h', '7d', '30d']).optional() },
+}, wrap(({ project, period }) => client().analytics(project, period)));
+
+server.registerTool('analytics_users', {
+  description: 'Actividad por persona: requests, primera y última visita de cada usuario autenticado.',
+  inputSchema: { project: z.string(), period: z.enum(['24h', '7d', '30d']).optional() },
+}, wrap(({ project, period }) => client().analyticsUsers(project, period)));
+
+server.registerTool('changelog', {
+  description: 'Historia del proyecto: versiones con autor y mensaje, más acciones (shares, rollbacks, secrets) del audit log.',
+  inputSchema: { project: z.string() },
+}, wrap(({ project }) => client().changelog(project)));
+
+server.registerTool('secrets_set', {
+  description: 'Guarda secrets del proyecto (cifrados). Se inyectan como variables de entorno y la app se reinicia con los valores nuevos. Nombres: MAYUSCULAS_CON_GUION_BAJO.',
+  inputSchema: { project: z.string(), secrets: z.record(z.string()).describe('{"STRIPE_KEY": "sk_..."}') },
+}, wrap(({ project, secrets }) => client().secretsSet(project, secrets)));
+
+server.registerTool('secrets_list', {
+  description: 'Lista los nombres de los secrets del proyecto (los valores nunca se devuelven).',
+  inputSchema: { project: z.string() },
+}, wrap(({ project }) => client().secretsList(project)));
+
+server.registerTool('ai_status', {
+  description: 'Estado del BYO Claude del workspace: si hay una cuenta de Claude conectada (suscripción o API key) y qué proyectos tienen IA habilitada. Las apps con IA pueden ejecutar `claude -p "prompt"` con la cuenta del dueño — pensado para proyectos personales o de poco uso.',
+  inputSchema: {},
+}, wrap(() => client().aiStatus()));
+
+server.registerTool('ai_enable', {
+  description: 'Habilita IA en un proyecto (Node o Python): la microVM recibe la credencial de Claude del dueño y el CLI `claude` queda en el PATH — la app puede ejecutar `claude -p "..." --output-format json` (usá child_process/subprocess). Requiere cuenta conectada (el humano corre `claude setup-token` + `alora ai connect` una vez). El primer arranque instala el CLI (~1 min); después es instantáneo. Con suscripción: solo para uso personal/bajo — el rate limit se comparte con el uso interactivo del dueño; para tráfico real conviene API key.',
+  inputSchema: { project: z.string() },
+}, wrap(({ project }) => client().aiSetProject(project, true)));
+
+server.registerTool('ai_disable', {
+  description: 'Deshabilita la IA en un proyecto: la app se reinicia sin la credencial de Claude.',
+  inputSchema: { project: z.string() },
+}, wrap(({ project }) => client().aiSetProject(project, false)));
+
+server.registerTool('wallet_balance', {
+  description: 'Saldo prepago del workspace y últimos movimientos del ledger. El saldo se carga en https://alora.build/wallet (checkout de Paddle) — el agente no puede cargar plata, solo el humano.',
+  inputSchema: {},
+}, wrap(() => client().wallet()));
+
+server.registerTool('project_trash', {
+  description: 'Manda un proyecto a la papelera: la URL deja de responder, restaurable por 30 días, después se purga solo. Nunca borra datos de inmediato.',
+  inputSchema: { project: z.string() },
+}, wrap(({ project }) => client().trash(project)));
+
+server.registerTool('project_restore', {
+  description: 'Restaura un proyecto de la papelera, intacto (código, datos, miembros).',
+  inputSchema: { project: z.string() },
+}, wrap(({ project }) => client().restore(project)));
+
+const transport = new StdioServerTransport();
+await server.connect(transport);