alora-mcp 0.5.0 → 0.7.0

package/README.md

@@ -0,0 +1,62 @@
+# alora-mcp
+
+MCP server for [Alora](https://alora.build) — the cloud where your agent works.
+
+Give your coding agent a place to **actually ship**: it deploys the apps it writes to real infrastructure, shares them by email, previews changes before production, runs 24/7 workers and cron jobs, and even buys domains (with your approval). You talk to the agent; the agent talks to Alora.
+
+Works with Claude Code, Codex, Cursor, and any MCP client.
+
+## Install
+
+```bash
+# Claude Code
+claude mcp add alora -- npx alora-mcp
+
+# Codex
+codex mcp add alora -- npx alora-mcp
+```
+
+Or in any MCP client's JSON config:
+
+```json
+{
+  "mcpServers": {
+    "alora": { "command": "npx", "args": ["alora-mcp"] }
+  }
+}
+```
+
+## Connect (once, takes a minute)
+
+1. Create a free account at [alora.build/register](https://alora.build/register) — $0.50 of credit included, no card.
+2. Run `npx alora-cli connect` in your terminal — it prints a code.
+3. Paste the code at [alora.build/activate](https://alora.build/activate).
+
+The token lands in `~/.alora/config.json`, and from then on your agent takes it from here. Full playbook for agents: [alora.build/llms.txt](https://alora.build/llms.txt).
+
+## What your agent can do (45 tools)
+
+| | |
+|---|---|
+| **Ship** | `create_project` · `deploy` (Node, Python, static, or any command via Procfile/alora.json) · `list_versions` · `rollback` |
+| **Preview before prod** | `preview` → temporary URL at `myapp--preview.alora.page` with throwaway data · `promote` · `preview_stop` |
+| **Share** | apps are born private — `share` by email with roles, `set_visibility`, `revoke_access` |
+| **Run things** | `set_always_on` / `set_worker_mode` for 24/7 processes · `cron_create` for scheduled hits · `exec` · `restart` · `logs` |
+| **Configure** | `secrets_set` (encrypted, injected as env) · `domain_connect` · `egress_ip_allocate` (static egress IP) |
+| **Use AI inside the app** | `ai_enable` — the deployed app runs `claude -p` with the owner's own Claude account |
+| **Buy domains** | `domain_search` · `domain_buy` — always gated on the owner's approval by email |
+| **Know what's happening** | `analytics_summary` · `analytics_users` · `wallet_balance` · `changelog` |
+
+## How it behaves
+
+- **Apps are born private.** Visitors get a login page; the owner invites people by email. Your agent never writes auth code — identity arrives as trusted headers.
+- **Spending has a hard ceiling.** Prepaid credits only: $0.01 per active hour, $0 while an app sleeps, $0.40/GB/month storage. An agent can't spend what you didn't load. Typical side project: under $1/month.
+- **Irreversible actions ask a human.** Domain purchases require the owner to click an approval email.
+- **Data persists.** Each app gets a data directory that survives deploys, restarts and sleep.
+
+## Links
+
+- Website: [alora.build](https://alora.build) · [Pricing](https://alora.build/pricing) · [Blog](https://alora.build/blog)
+- Agent docs: [alora.build/llms.txt](https://alora.build/llms.txt)
+- CLI for humans: [`alora-cli`](https://www.npmjs.com/package/alora-cli) · API client: [`alora-sdk`](https://www.npmjs.com/package/alora-sdk)
+- Feedback (agents welcome): the `send_feedback` tool, or hola@alora.build

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "alora-mcp",
-  "version": "0.5.0",
-  "description": "Servidor MCP de Alora — Claude Code, Codex, Cursor y cualquier cliente MCP",
+  "version": "0.7.0",
+  "description": "MCP server for Alora, the cloud where your agent works — deploy, preview, share and run the apps your agent writes. Claude Code, Codex, Cursor and any MCP client.",
   "type": "module",
   "bin": {
     "alora-mcp": "src/index.js"
   },
   "dependencies": {
-    "alora-sdk": "^0.5.0",
+    "alora-sdk": "^0.7.0",
     "@modelcontextprotocol/sdk": "^1.12.0",
     "tar": "^7.4.3",
     "zod": "^3.24.0"

package/src/index.js

@@ -4,7 +4,7 @@
 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 { readFileSync, rmSync, writeFileSync, mkdirSync } from 'node:fs';
 import { homedir, tmpdir } from 'node:os';
 import path from 'node:path';
 import * as tar from 'tar';
@@ -18,7 +18,7 @@ function client() {
   return new AloraClient({ api: cfg.api || 'https://api.alora.build', token: cfg.token });
 }
 
-const server = new McpServer({ name: 'alora', version: '0.1.0' });
+const server = new McpServer({ name: 'alora', version: '0.7.0' });
 
 const ok = (data) => ({ content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] });
 const asError = (e) => ({
@@ -43,6 +43,30 @@ server.registerTool('whoami', {
   inputSchema: {},
 }, wrap(() => client().whoami()));
 
+// --- alta iniciada por el agente: el usuario solo toca UN email ---
+server.registerTool('account_create_and_connect', {
+  description: 'SIN cuenta de Alora todavía: preguntale al usuario su email EN EL CHAT y llamá esta tool. Le llega UN email; con un click se crea la cuenta (si no existe), se verifica, se activan sus US$0.50 gratis y este agente queda autorizado. Después llamá account_connect_poll con el device_code hasta que apruebe (el link vence en 15 min). NUNCA inventes un email ni uses uno descartable — tiene que ser el inbox real del usuario. Si el email ya tiene cuenta, le llega un pedido de autorización al flujo normal (login + Authorize).',
+  inputSchema: {
+    email: z.string().describe('El email que el usuario te dio en el chat'),
+    agent_name: z.string().optional().describe('Cómo se llama este agente, ej: "Claude de Ana"'),
+  },
+}, wrap(({ email, agent_name }) => client().signupStart(email, agent_name || 'agente MCP')));
+
+server.registerTool('account_connect_poll', {
+  description: 'Después de account_create_and_connect: llamá esto cada ~5s con el device_code. Cuando el usuario toque el email devuelve approved y GUARDA el token automáticamente — desde ahí todas las demás tools funcionan. expired = el link venció sin click: pedile al usuario que revise el inbox y volvé a empezar.',
+  inputSchema: { device_code: z.string() },
+}, wrap(async ({ device_code }) => {
+  const res = await client().devicePoll(device_code);
+  if (res.status === 'approved' && res.token) {
+    let cfg = {};
+    try { cfg = JSON.parse(readFileSync(CONFIG_FILE, 'utf8')); } catch {}
+    mkdirSync(path.dirname(CONFIG_FILE), { recursive: true });
+    writeFileSync(CONFIG_FILE, JSON.stringify({ ...cfg, api: cfg.api || 'https://api.alora.build', token: res.token }, null, 2));
+    return { status: 'approved', note: 'Token guardado — ya podés usar todas las tools (probá whoami).' };
+  }
+  return res;
+}));
+
 server.registerTool('list_projects', {
   description: 'Lista los proyectos del workspace con URL, versión activa y estado.',
   inputSchema: {},
@@ -54,13 +78,19 @@ server.registerTool('create_project', {
 }, 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.',
+  description: 'Despliega un directorio local como nueva versión del proyecto. Detecta el runtime solo (Node, Python, estático). Arranque: "main"/server.js, `npm start`, un Procfile ("web: ...") o alora.json {"start": "cualquier comando"}. Frontends (Vite/Next/Astro…): pasá build (ej: "npm run build") y dir apuntando a la salida (dist/). Estáticos tienen fallback SPA a index.html. Devuelve la URL.',
   inputSchema: {
     project: z.string().describe('Nombre del proyecto'),
-    dir: z.string().describe('Ruta absoluta del directorio a desplegar'),
+    dir: z.string().describe('Ruta absoluta del directorio a desplegar (para un frontend buildeado, la carpeta de salida: dist/, build/, out/)'),
     message: z.string().optional().describe('Mensaje corto describiendo el cambio'),
+    build: z.string().optional().describe('Comando a correr antes (en el directorio del proyecto), ej: "npm run build"'),
+    base_version: z.number().optional().describe('Versión de la que partiste: si otro agente desplegó mientras tanto, falla con version_conflict en vez de pisar su trabajo'),
   },
-}, wrap(async ({ project, dir, message }) => {
+}, wrap(async ({ project, dir, message, build, base_version }) => {
+  if (build) {
+    const { execSync } = await import('node:child_process');
+    execSync(build, { cwd: dir, stdio: 'ignore' });
+  }
   const tmpFile = path.join(tmpdir(), `alora-mcp-${Date.now()}.tgz`);
   await tar.create(
     {
@@ -71,9 +101,41 @@ server.registerTool('deploy', {
   );
   const buffer = readFileSync(tmpFile);
   rmSync(tmpFile, { force: true });
-  return client().deploy(project, buffer, { message });
+  return client().deploy(project, buffer, { message, base_version });
+}));
+
+server.registerTool('preview', {
+  description: 'Despliega un candidato a una URL TEMPORAL (<proyecto>--preview) SIN tocar la versión viva. El loop con el humano: subís el cambio acá, le pasás el link para que lo mire, y recién si le gusta lo promovés a producción con `promote`. Datos efímeros (no comparte el /data de prod). Expira en 24h. Mismo runtime/detección/build que deploy. Devolvé preview_url al humano.',
+  inputSchema: {
+    project: z.string(),
+    dir: z.string().describe('Ruta absoluta del directorio a desplegar (para un frontend buildeado, la carpeta de salida)'),
+    message: z.string().optional(),
+    build: z.string().optional().describe('Comando a correr antes, ej: "npm run build"'),
+  },
+}, wrap(async ({ project, dir, message, build }) => {
+  if (build) { const { execSync } = await import('node:child_process'); execSync(build, { cwd: dir, stdio: 'ignore' }); }
+  const tmpFile = path.join(tmpdir(), `alora-preview-${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().preview(project, buffer, { message });
 }));
 
+server.registerTool('promote', {
+  description: 'Promueve a producción el preview del proyecto (o una versión puntual). Lo que estaba en la URL temporal pasa a ser la versión viva; el preview se baja. Usalo cuando el humano aprobó lo que le mostraste con `preview`.',
+  inputSchema: { project: z.string(), version: z.number().optional().describe('Versión a promover; por default, la del preview activo') },
+}, wrap(({ project, version }) => client().promote(project, version)));
+
+server.registerTool('preview_stop', {
+  description: 'Baja el preview de un proyecto (la URL temporal deja de responder). La app viva no se toca.',
+  inputSchema: { project: z.string() },
+}, wrap(({ project }) => client().previewStop(project)));
+
+server.registerTool('preview_status', {
+  description: 'Muestra si hay un preview activo, su URL temporal, la versión y cuándo expira.',
+  inputSchema: { project: z.string() },
+}, wrap(({ project }) => client().previewInfo(project)));
+
 server.registerTool('project_status', {
   description: 'Estado de un proyecto: versión activa, si está corriendo, URL.',
   inputSchema: { project: z.string() },