alora-mcp 0.1.0 → 0.3.0

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "alora-mcp",
-  "version": "0.1.0",
+  "version": "0.3.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",
+    "alora-sdk": "^0.3.0",
     "@modelcontextprotocol/sdk": "^1.12.0",
     "tar": "^7.4.3",
     "zod": "^3.24.0"

package/src/index.js

@@ -80,12 +80,33 @@ server.registerTool('project_status', {
 }, 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.',
+  description: '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'),
+    since: z.string().optional().describe('Solo líneas posteriores a este instante (ISO o ms epoch)'),
   },
-}, wrap(({ project, lines }) => client().logs(project, { lines })));
+}, wrap(({ project, lines, since }) => client().logs(project, { lines, since })));
+
+server.registerTool('exec', {
+  description: 'Ejecuta un comando dentro de la microVM del proyecto (despierta la máquina si duerme). Devuelve stdout, stderr y exit_code. Para inspeccionar el filesystem, ver archivos en /data, debuggear. Ej: "ls -la /data", "cat /data/bitacora/hoy.log".',
+  inputSchema: { project: z.string(), command: z.string() },
+}, wrap(({ project, command }) => client().exec(project, command)));
+
+server.registerTool('restart', {
+  description: 'Reinicia la app sin redesplegar (útil para aplicar un cambio de estado o salir de un cuelgue).',
+  inputSchema: { project: z.string() },
+}, wrap(({ project }) => client().restart(project)));
+
+server.registerTool('cron_run', {
+  description: 'Dispara un cron AHORA (sin esperar su horario). Devuelve el status y el body de la respuesta de la app — útil para probar y ver el traceback si falla.',
+  inputSchema: { project: z.string(), id: z.string() },
+}, wrap(({ project, id }) => client().cronRun(project, id)));
+
+server.registerTool('token_create', {
+  description: 'Crea un token de acceso por proyecto que BYPASSEA el login: un script/webhook/backup externo puede pegarle a la URL de la app con Authorization: Bearer <token> sin SSO. Scoped a este proyecto y revocable. La app lo ve con x-alora-user-role: service. El token se muestra una sola vez.',
+  inputSchema: { project: z.string(), name: z.string().optional() },
+}, wrap(({ project, name }) => client().tokenCreate(project, name)));
 
 server.registerTool('list_versions', {
   description: 'Historial de versiones del proyecto, con autor y mensaje.',
@@ -164,6 +185,72 @@ server.registerTool('ai_disable', {
   inputSchema: { project: z.string() },
 }, wrap(({ project }) => client().aiSetProject(project, false)));
 
+server.registerTool('set_always_on', {
+  description: 'Enciende o apaga el modo siempre-encendido de un proyecto. Por default las apps DUERMEN sin tráfico (escala a cero, casi gratis). Con always_on=true la VM no duerme: sirve para watchers 24/7, loops que tickean cada X segundos, cron propio de la app, y ciclos largos de `claude -p` (minutos) que corren de fondo sin depender de un request HTTP. Cuesta ~US$7-14/mes de cómputo activo.',
+  inputSchema: { project: z.string(), always_on: z.boolean() },
+}, wrap(({ project, always_on }) => client().scale(project, { always_on })));
+
+server.registerTool('set_worker_mode', {
+  description: 'Convierte un proyecto en worker headless 24/7 (sin HTTP): un proceso de fondo — watcher, cron, motor que llama `claude -p` en loop — que corre siempre y se reinicia solo si cae. Implica always-on. Para volver a app web: mode="web". Requiere runtime Node o Python. El estado persiste en DATA_DIR.',
+  inputSchema: { project: z.string(), mode: z.enum(['web', 'worker']) },
+}, wrap(({ project, mode }) => client().scale(project, { mode })));
+
+server.registerTool('cron_create', {
+  description: 'Programa una tarea recurrente: Alora hace GET a <path> de tu app en el horario dado (cron de 5 campos, UTC). Si la app duerme, el disparo la despierta, corre la tarea y se vuelve a dormir — la forma barata de "correr un rato cada tanto" sin always-on. Tu app reconoce el disparo por el header x-alora-cron: 1. Para procesos continuos (cada segundos) usá worker en su lugar.',
+  inputSchema: {
+    project: z.string(),
+    schedule: z.string().describe('cron UTC: "0 * * * *" cada hora, "*/5 * * * *" cada 5 min, "5 0,12 * * *" 00:05 y 12:05'),
+    path: z.string().describe('ruta que tu app maneja, ej: /cron/hourly'),
+    once: z.boolean().optional().describe('si true, se borra solo tras correr una vez'),
+  },
+}, wrap(({ project, schedule, path, once }) => client().cronCreate(project, schedule, path, once)));
+
+server.registerTool('cron_list', {
+  description: 'Lista las tareas programadas de un proyecto con su último disparo y estado.',
+  inputSchema: { project: z.string() },
+}, wrap(({ project }) => client().cronList(project)));
+
+server.registerTool('cron_delete', {
+  description: 'Elimina una tarea programada por su id.',
+  inputSchema: { project: z.string(), id: z.string() },
+}, wrap(({ project, id }) => client().cronDelete(project, id)));
+
+server.registerTool('send_feedback', {
+  description: 'Envía feedback a los que hacen Alora. Usalo cuando choques con un límite, necesites una capacidad que no existe, o se te ocurra una forma mejor de usar la plataforma para lo que el usuario quiere hacer. Le llega directo al equipo. No es para errores de tu app (eso es logs) — es para lo que Alora debería poder hacer y todavía no puede.',
+  inputSchema: {
+    message: z.string().describe('Qué necesitás o cómo querrías usar Alora'),
+    category: z.enum(['feature-request', 'limitation', 'idea', 'bug', 'general']).optional(),
+  },
+}, wrap(({ message, category }) => client().feedback(message, { category })));
+
+server.registerTool('domain_search', {
+  description: 'Chequea disponibilidad de un nombre en 10 TLDs con precio aproximado. La compra dentro de Alora llega pronto; hoy el dueño lo compra donde prefiera y se conecta con domain_connect.',
+  inputSchema: { name: z.string().describe('Nombre sin TLD, ej: "miempresa"') },
+}, wrap(({ name }) => client().domainSearch(name)));
+
+server.registerTool('domain_connect', {
+  description: 'Conecta un dominio propio del dueño a un proyecto. Devuelve los registros DNS a cargar; el TLS se emite solo al detectarlos. El login de Alora funciona igual en el dominio custom.',
+  inputSchema: { project: z.string(), domain: z.string().describe('ej: app.miempresa.com') },
+}, wrap(({ project, domain }) => client().domainConnect(project, domain)));
+
+server.registerTool('domain_list', {
+  description: 'Dominios conectados a un proyecto con su estado de DNS y certificado TLS.',
+  inputSchema: { project: z.string() },
+}, wrap(({ project }) => client().domainList(project)));
+
+server.registerTool('domain_buy', {
+  description: 'Inicia la COMPRA de un dominio con el saldo del workspace. Es plata real e irreversible, así que SIEMPRE requiere que el dueño humano apruebe por email (vence en 24h) — vos no podés completarla solo. Requiere saldo suficiente. Seguí el estado con approval_status. Con project, al aprobarse queda conectado y con TLS solo.',
+  inputSchema: {
+    domain: z.string().describe('ej: miempresa.com'),
+    project: z.string().optional().describe('Proyecto al que conectarlo al aprobarse'),
+  },
+}, wrap(({ domain, project }) => client().domainBuy(domain, project)));
+
+server.registerTool('approval_status', {
+  description: 'Estado de una aprobación pendiente (ej: compra de dominio): pending, approved, denied, failed o expired.',
+  inputSchema: { id: z.string() },
+}, wrap(({ id }) => client().approvalStatus(id)));
+
 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: {},