alora-mcp 0.4.0 → 0.6.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.4.0",
-  "description": "Servidor MCP de Alora — Claude Code, Codex, Cursor y cualquier cliente MCP",
+  "version": "0.6.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.4.0",
+    "alora-sdk": "^0.6.0",
     "@modelcontextprotocol/sdk": "^1.12.0",
     "tar": "^7.4.3",
     "zod": "^3.24.0"

package/src/index.js

@@ -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.6.0' });
 
 const ok = (data) => ({ content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] });
 const asError = (e) => ({
@@ -54,13 +54,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 +77,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() },
@@ -109,10 +147,15 @@ server.registerTool('egress_ip', {
 }, wrap(({ project }) => client().egressIp(project)));
 
 server.registerTool('egress_ip_allocate', {
-  description: 'Asigna una IP de egreso ESTÁTICA y dedicada al proyecto (sobrevive migraciones y reinicios) y reinicia la app para tomarla. Para apps que operan APIs con whitelist de IP: exchanges de cripto (Binance exige IP restringida para trading), bancos, brokers, SaaS enterprise. Whitelisteá la IP devuelta.',
+  description: 'Asigna una IP de egreso ESTÁTICA y dedicada al proyecto (add-on pago, ~US$4/mes debitado del saldo; primer mes al asignar y luego mensual). Sobrevive migraciones y reinicios; reinicia la app para tomarla. Para apps que operan APIs con whitelist de IP: exchanges de cripto (Binance exige IP restringida para trading), bancos, brokers, SaaS enterprise. Requiere saldo. Si el saldo no cubre la renovación, la IP se libera y se avisa. Whitelisteá la IP devuelta.',
   inputSchema: { project: z.string() },
 }, wrap(({ project }) => client().egressIpAllocate(project)));
 
+server.registerTool('egress_ip_release', {
+  description: 'Libera la IP de egreso dedicada del proyecto y deja de cobrarla. La IP de egreso vuelve a ser compartida (puede cambiar).',
+  inputSchema: { project: z.string() },
+}, wrap(({ project }) => client().egressIpRelease(project)));
+
 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() },