citaspro-cli 1.0.2

package/README.md

@@ -0,0 +1,68 @@
+# citaspro-cli
+
+CLI para gestionar leads, reservas y calendario de CitasPro.
+
+## Instalacion
+
+```bash
+npm install -g citaspro-cli
+```
+
+## Inicio rapido
+
+```bash
+citaspro-cli login
+citaspro-cli whoami
+citaspro-cli leads:list
+citaspro-cli bookings:list
+```
+
+## Autenticacion
+
+```bash
+citaspro-cli login
+citaspro-cli whoami
+citaspro-cli logout
+```
+
+## Comandos principales
+
+### Leads
+
+```bash
+citaspro-cli leads:list
+citaspro-cli leads:get <lead_id|email|telefono>
+citaspro-cli leads:create '{"nombre":"Juan","email":"juan@demo.com","telefono":"+34612345678"}'
+```
+
+### Reservas
+
+```bash
+citaspro-cli bookings:list
+citaspro-cli tools:availability 2026-02-20 10:00 10:30
+citaspro-cli tools:create-booking '{"fecha":"2026-02-20","hora_inicio":"10:00","hora_fin":"10:30","contacto_nombre":"Juan","contacto_email":"juan@demo.com"}'
+citaspro-cli bookings:reschedule <booking_id> 2026-02-21 11:00 11:30
+citaspro-cli tools:cancel-booking <booking_id>
+```
+
+### Calendario y llamadas
+
+```bash
+citaspro-cli tools:caldav
+citaspro-cli tools:call +34612345678 "Recordatorio de cita"
+```
+
+## Modo agente / automatizacion
+
+```bash
+citaspro-cli ai:manifest
+citaspro-cli whoami --json
+citaspro-cli leads:list 20 --json
+citaspro-cli bookings:list 20 --json
+```
+
+## Ayuda
+
+```bash
+citaspro-cli --help
+```

package/citasproctl.js

@@ -0,0 +1,1021 @@
+#!/usr/bin/env node
+try {
+  require('dotenv').config();
+} catch (_error) {
+  // dotenv es opcional para el CLI
+}
+const axios = require('axios');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { exec, execSync } = require('child_process');
+
+function isEnabled(value) {
+  return ['1', 'true', 'yes', 'on'].includes(String(value || '').toLowerCase());
+}
+
+function normalizeBaseUrl(url) {
+  return String(url || '').replace(/\/+$/, '');
+}
+
+function resolveApiBase() {
+  if (process.env.CITAS_API_URL) {
+    return normalizeBaseUrl(process.env.CITAS_API_URL);
+  }
+
+  const useLocalhost = isEnabled(process.env.CITAS_USE_LOCALHOST) || isEnabled(process.env.CITAS_CLI_USE_LOCALHOST);
+  if (useLocalhost) {
+    const localPort = process.env.CITAS_LOCAL_PORT || process.env.PORT || '3000';
+    return `http://localhost:${localPort}`;
+  }
+
+  return 'https://citaspro.cloud';
+}
+
+const API_BASE = resolveApiBase();
+const AUTH_FILE = process.env.CITAS_CLI_AUTH_FILE || path.join(os.homedir(), '.citas-cli-auth.json');
+
+const USE_COLOR = Boolean(process.stdout.isTTY) && process.env.NO_COLOR !== '1';
+const ANSI = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+  gray: '\x1b[90m',
+};
+
+function colorize(text, color) {
+  if (!USE_COLOR) {
+    return text;
+  }
+  return `${ANSI[color] || ''}${text}${ANSI.reset}`;
+}
+
+function bold(text) {
+  return colorize(text, 'bold');
+}
+
+function usage() {
+  console.log(`
+CitasPro CLI
+============
+
+${bold('USO:')}
+  node tools/citas-cli.js <comando> [argumentos] [--json]
+  node tools/citas-cli.js --openclaw [nombre_agente]
+  node tools/citas-cli.js --openclaw [nombre_agente] --whatsapp
+
+${bold('ENTORNO API:')}
+  Default:                             https://citaspro.cloud
+  Override directo:                    CITAS_API_URL=https://mi-api
+  Modo local:                          CITAS_USE_LOCALHOST=1
+  Puerto local opcional:               CITAS_LOCAL_PORT=3000
+  (alias modo local):                  CITAS_CLI_USE_LOCALHOST=1
+
+${bold('INICIO RAPIDO (HUMANO):')}
+  node tools/citas-cli.js login
+  node tools/citas-cli.js whoami
+  node tools/citas-cli.js leads:list
+  node tools/citas-cli.js bookings:list
+
+${bold('MODO IA / AGENTE:')}
+  ${colorize('--json', 'cyan')}                              Fuerza salida JSON estable
+  ${colorize('--openclaw', 'cyan')} [nombre_agente]         Crea subagente OpenClaw en ~/clawd
+  ${colorize('--whatsapp', 'cyan')}                         Configura login del canal WhatsApp
+  ${colorize('ai:manifest', 'cyan')}                         Describe comandos, argumentos y salida
+  node tools/citas-cli.js whoami --json
+
+${bold('AUTENTICACION:')}
+  ${colorize('login', 'cyan')}                               OAuth Device Flow (abre navegador y espera)
+  ${colorize('logout', 'cyan')}                              Elimina sesión local
+  ${colorize('whoami', 'cyan')}                              Muestra usuario, tenant y tipo auth
+
+${bold('LEADS:')}
+  ${colorize('leads:list', 'cyan')} [limit]                  Lista leads (default: 20)
+  ${colorize('leads:get', 'cyan')} <id|email|phone>          Obtiene un lead
+  ${colorize('leads:create', 'cyan')} '<json>'               Crea lead (nombre + email obligatorios)
+
+${bold('RESERVAS:')}
+  ${colorize('bookings:list', 'cyan')} [limit]               Lista reservas
+  ${colorize('tools:availability', 'cyan')} <fecha> <hora_inicio> <hora_fin>
+                                      Valida disponibilidad
+  ${colorize('tools:create-booking', 'cyan')} '<json>'       Crea reserva
+  ${colorize('bookings:reschedule', 'cyan')} <id> <fecha> <hora_inicio> <hora_fin>
+                                      Reprograma reserva
+  ${colorize('tools:cancel-booking', 'cyan')} <id>           Cancela reserva
+
+${bold('CALENDARIO / LLAMADAS:')}
+  ${colorize('tools:caldav', 'cyan')}                        Devuelve enlace CalDAV
+  ${colorize('tools:call', 'cyan')} <to> [message]           Llamada (real o simulada)
+
+${bold('DEVICE FLOW (MANUAL):')}
+  ${colorize('device:start', 'cyan')}                        Genera device_code + user_code
+  ${colorize('device:poll', 'cyan')} <device_code>           Intercambia device_code por token
+
+${bold('ALIASES (cortos):')}
+  leads ls [limit]
+  leads get <id|email|phone>
+  leads add '<json>'
+  bookings ls [limit]
+  bookings mv <id> <fecha> <hora_inicio> <hora_fin>
+  bookings rm <id>
+  calendar avail <fecha> <hora_inicio> <hora_fin>
+  calendar caldav
+  call <to> [message]
+
+${bold('EJEMPLOS:')}
+  node tools/citas-cli.js --openclaw ventas-bot
+  node tools/citas-cli.js --openclaw ventas-bot --whatsapp
+  node tools/citas-cli.js leads:create '{"nombre":"Juan","email":"juan@demo.com","telefono":"+34612345678"}'
+  node tools/citas-cli.js tools:create-booking '{"fecha":"2026-02-20","hora_inicio":"10:00","hora_fin":"10:30","contacto_nombre":"Juan","contacto_email":"juan@demo.com"}'
+  node tools/citas-cli.js bookings:list 20 --json
+`);
+}
+
+const AI_MANIFEST = {
+  name: 'citaspro-cli',
+  version: '1.0.0',
+  base_url: API_BASE,
+  auth: {
+    mode: 'device_flow_local_session',
+    login_command: 'node tools/citas-cli.js login',
+  },
+  global_flags: ['--json', '--openclaw', '--whatsapp'],
+  commands: [
+    { id: 'whoami', args: [], returns: ['user', 'tenant_id', 'auth_type'] },
+    { id: 'leads:list', args: ['limit?'], returns: ['count', 'leads[]'] },
+    { id: 'leads:get', args: ['id|email|phone'], returns: ['lead'] },
+    { id: 'leads:create', args: ['json_payload'], returns: ['lead'] },
+    { id: 'bookings:list', args: ['limit?'], returns: ['count', 'bookings[]'] },
+    { id: 'tools:availability', args: ['fecha', 'hora_inicio', 'hora_fin'], returns: ['available', 'reasons', 'conflicts[]'] },
+    { id: 'tools:create-booking', args: ['json_payload'], returns: ['booking'] },
+    { id: 'bookings:reschedule', args: ['booking_id', 'fecha', 'hora_inicio', 'hora_fin'], returns: ['booking'] },
+    { id: 'tools:cancel-booking', args: ['booking_id'], returns: ['booking'] },
+    { id: 'tools:caldav', args: [], returns: ['caldav_url', 'radicale_username', 'calendar_id'] },
+    { id: 'tools:call', args: ['to', 'message?'], returns: ['status', 'provider', 'to'] },
+    { id: 'openclaw:init', args: ['agent_name?'], returns: ['output_dir', 'files[]', 'prompt_preview'] },
+  ],
+};
+
+function looksLikeToken(value) {
+  if (typeof value !== 'string') {
+    return false;
+  }
+  return value.startsWith('cli_') || value.startsWith('rcli_') || value.split('.').length === 3;
+}
+
+function looksLikePayload(value) {
+  if (typeof value !== 'string') {
+    return false;
+  }
+  const trimmed = value.trim();
+  return trimmed.startsWith('{') || trimmed.startsWith('[');
+}
+
+function readSession() {
+  try {
+    if (!fs.existsSync(AUTH_FILE)) {
+      return null;
+    }
+
+    const raw = fs.readFileSync(AUTH_FILE, 'utf8');
+    const parsed = JSON.parse(raw);
+
+    if (!parsed?.access_token) {
+      return null;
+    }
+
+    return parsed;
+  } catch (_error) {
+    return null;
+  }
+}
+
+function writeSession(session) {
+  const dir = path.dirname(AUTH_FILE);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(AUTH_FILE, JSON.stringify(session, null, 2), 'utf8');
+}
+
+function clearSession() {
+  if (fs.existsSync(AUTH_FILE)) {
+    fs.unlinkSync(AUTH_FILE);
+  }
+}
+
+async function post(pathname, data = {}, token = null) {
+  const headers = { 'Content-Type': 'application/json' };
+  if (token) {
+    headers.Authorization = `Bearer ${token}`;
+  }
+
+  const response = await axios.post(`${API_BASE}${pathname}`, data, {
+    headers,
+    timeout: 15000,
+    // Evita problemas de proxy/entorno que provocan ECONNRESET "socket hang up"
+    proxy: false,
+  });
+  return response.data;
+}
+
+async function get(pathname, token = null) {
+  const headers = {};
+  if (token) {
+    headers.Authorization = `Bearer ${token}`;
+  }
+
+  const response = await axios.get(`${API_BASE}${pathname}`, {
+    headers,
+    timeout: 15000,
+    proxy: false,
+  });
+  return response.data;
+}
+
+function sanitizeAgentName(name) {
+  const raw = String(name || '').trim() || 'nombreagente';
+  const sanitized = raw
+    .normalize('NFD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .replace(/[^a-zA-Z0-9-_]/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '');
+  return sanitized || 'nombreagente';
+}
+
+async function fetchPromptFromAi(token) {
+  const fallback = {
+    prompt: 'Eres un asistente profesional para gestión de citas.',
+    tone: 'neutro',
+    templateName: '',
+    companyData: {},
+  };
+
+  try {
+    const data = await get('/api/prompts-and-templates', token);
+    const templates = Array.isArray(data?.templates) ? data.templates : [];
+    const defaultName = String(data?.defaultTemplateName || '').trim();
+    const selected = templates.find((t) => t?.isDefault || t?.name === defaultName) || templates[0];
+
+    if (!selected) {
+      return fallback;
+    }
+
+    return {
+      prompt: String(selected?.prompt || fallback.prompt).trim() || fallback.prompt,
+      tone: String(selected?.tone || fallback.tone).trim() || fallback.tone,
+      templateName: String(selected?.name || '').trim(),
+      companyData: selected?.companyData || selected?.company_data || {},
+    };
+  } catch (_error) {
+    return fallback;
+  }
+}
+
+function buildOpenClawFiles({ agentName, promptConfig, whatsapp }) {
+  const companyName = String(promptConfig?.companyData?.name || 'CitasPro');
+  const promptText = String(promptConfig?.prompt || 'Eres un asistente profesional para gestión de citas.');
+  const tone = String(promptConfig?.tone || 'neutro');
+
+  const soul = `# SOUL
+
+## Identidad
+Eres un subagente de OpenClaw orientado a operación comercial y agenda en CitasPro.
+
+## Misión
+- Capturar y actualizar leads.
+- Crear, mover y cancelar reservas.
+- Mantener sincronización entre CRM y calendario.
+
+## Aislamiento
+- Este agente usa workspace dedicado.
+- No debe leer ni operar datos de otros agentes/tenants.
+- Solo ejecutar acciones sobre su contexto asignado.
+
+## Prompt base extraído de /ai
+\`\`\`text
+${promptText}
+\`\`\`
+
+## Contexto de negocio
+- Empresa: ${companyName}
+- Tono: ${tone}
+
+## LLM recomendado
+- Provider: OpenRouter
+- Modelo sugerido: kimi-k2
+`;
+
+  const skill = `---
+name: ${agentName}
+description: Subagente para operar CitasPro (leads, reservas y calendario) desde OpenClaw.
+---
+
+# SKILL
+
+## Flujo recomendado
+1. Identidad del operador
+- \`citaspro-cli whoami --json\`
+
+2. Leads
+- \`citaspro-cli leads:list 20 --json\`
+- \`citaspro-cli get <id|email|telefono> --json\`
+- \`citaspro-cli leads:create '<json>' --json\`
+
+3. Agenda
+- \`citaspro-cli tools:availability <fecha> <inicio> <fin> --json\`
+- \`citaspro-cli tools:create-booking '<json>' --json\`
+- \`citaspro-cli bookings:reschedule <id> <fecha> <inicio> <fin> --json\`
+- \`citaspro-cli tools:cancel-booking <id> --json\`
+
+4. Calendario
+- \`citaspro-cli tools:caldav --json\`
+
+## Recomendación de modelo
+- Usar OpenRouter con modelo \`kimi-k2\` para este agente.
+`;
+
+  const heardbeat = `# HEARDBEAT
+
+## Checks
+1. Auth
+\`\`\`bash
+citaspro-cli whoami --json
+\`\`\`
+
+2. Leads
+\`\`\`bash
+citaspro-cli leads:list 1 --json
+\`\`\`
+
+3. Agenda
+\`\`\`bash
+citaspro-cli bookings:list 1 --json
+\`\`\`
+
+4. CalDAV
+\`\`\`bash
+citaspro-cli tools:caldav --json
+\`\`\`
+`;
+
+  const channels = `# CHANNELS
+
+## WhatsApp (channel scope)
+- allow all: true
+- account: ${whatsapp?.account || 'citaspro'}
+
+Ejemplo:
+\`\`\`json
+{
+  "channels": {
+    "whatsapp": {
+      "dmPolicy": "pairing",
+      "groupPolicy": "allowlist",
+      "allowFrom": [],
+      "groupAllowFrom": [],
+      "allowAll": true
+    }
+  }
+}
+\`\`\`
+`;
+
+  return { soul, skill, heardbeat, channels };
+}
+
+async function createOpenClawSubagent(agentName, token, options = {}) {
+  const safeName = sanitizeAgentName(agentName);
+  const rootDir = process.env.OPENCLAW_AGENTS_DIR || path.join(os.homedir(), 'clawd');
+  const agentDir = path.join(rootDir, safeName);
+  const skillDir = path.join(agentDir, 'skills', 'citaspro');
+  const promptConfig = await fetchPromptFromAi(token);
+  const whatsapp = {
+    enabled: Boolean(options?.whatsapp),
+    allow_all: true,
+    account: 'citaspro',
+  };
+  const files = buildOpenClawFiles({ agentName: safeName, promptConfig, whatsapp });
+
+  fs.mkdirSync(agentDir, { recursive: true });
+  fs.mkdirSync(skillDir, { recursive: true });
+  fs.writeFileSync(path.join(agentDir, 'SOUL.md'), files.soul, 'utf8');
+  fs.writeFileSync(path.join(skillDir, 'SKILL.md'), files.skill, 'utf8');
+  fs.writeFileSync(path.join(agentDir, 'HEARDBEAT.md'), files.heardbeat, 'utf8');
+  fs.writeFileSync(path.join(agentDir, 'CHANNELS.md'), files.channels, 'utf8');
+
+  // Intento de creación real del agente en OpenClaw (si el binario existe).
+  const openclaw = {
+    attempted: false,
+    created: false,
+    identity_set: false,
+    listed: false,
+    command: null,
+    details: null,
+    steps: [],
+  };
+
+  const createMode = String(process.env.OPENCLAW_CREATE_MODE || 'auto').toLowerCase();
+  if (createMode !== 'files-only') {
+    openclaw.attempted = true;
+    const escaped = safeName.replace(/"/g, '\\"');
+    const workspaceEscaped = agentDir.replace(/"/g, '\\"');
+    const identityName = String(process.env.OPENCLAW_AGENT_NAME || safeName);
+    const identityEmoji = String(process.env.OPENCLAW_AGENT_EMOJI || '☎️');
+    const identityNameEscaped = identityName.replace(/"/g, '\\"');
+    const identityEmojiEscaped = identityEmoji.replace(/"/g, '\\"');
+
+    const addCommand = `openclaw agents add "${escaped}" --workspace "${workspaceEscaped}"`;
+    try {
+      const out = execSync(addCommand, {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        encoding: 'utf8',
+      });
+      openclaw.created = true;
+      openclaw.command = addCommand;
+      openclaw.steps.push({ step: 'agents add', ok: true, command: addCommand, output: String(out || '').trim() });
+    } catch (error) {
+      const stderr = String(error?.stderr || '').trim();
+      const stdout = String(error?.stdout || '').trim();
+      const combined = `${stdout}\n${stderr}`.trim();
+      if (/already exists|ya existe/i.test(combined)) {
+        openclaw.created = true;
+        openclaw.steps.push({ step: 'agents add', ok: true, command: addCommand, output: combined || 'Agent already exists' });
+      } else {
+        openclaw.steps.push({ step: 'agents add', ok: false, command: addCommand, output: combined || error.message });
+      }
+    }
+
+    if (openclaw.created) {
+      const identityCommand = `openclaw agents set-identity --agent "${escaped}" --name "${identityNameEscaped}" --emoji "${identityEmojiEscaped}"`;
+      try {
+        const out = execSync(identityCommand, {
+          stdio: ['ignore', 'pipe', 'pipe'],
+          encoding: 'utf8',
+        });
+        openclaw.identity_set = true;
+        openclaw.steps.push({ step: 'agents set-identity', ok: true, command: identityCommand, output: String(out || '').trim() });
+      } catch (error) {
+        const stderr = String(error?.stderr || '').trim();
+        const stdout = String(error?.stdout || '').trim();
+        const combined = `${stdout}\n${stderr}`.trim();
+        openclaw.steps.push({ step: 'agents set-identity', ok: false, command: identityCommand, output: combined || error.message });
+      }
+
+      const listCommand = 'openclaw agents list';
+      try {
+        const out = execSync(listCommand, {
+          stdio: ['ignore', 'pipe', 'pipe'],
+          encoding: 'utf8',
+        });
+        openclaw.listed = true;
+        openclaw.steps.push({ step: 'agents list', ok: true, command: listCommand, output: String(out || '').trim() });
+      } catch (error) {
+        const stderr = String(error?.stderr || '').trim();
+        const stdout = String(error?.stdout || '').trim();
+        const combined = `${stdout}\n${stderr}`.trim();
+        openclaw.steps.push({ step: 'agents list', ok: false, command: listCommand, output: combined || error.message });
+      }
+
+      if (whatsapp.enabled) {
+        const accountEscaped = 'citaspro';
+        const loginCommand = `openclaw channels login --channel whatsapp --account "${accountEscaped}"`;
+        try {
+          const out = execSync(loginCommand, {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            encoding: 'utf8',
+          });
+          openclaw.steps.push({ step: 'channels login whatsapp', ok: true, command: loginCommand, output: String(out || '').trim() });
+        } catch (error) {
+          const stderr = String(error?.stderr || '').trim();
+          const stdout = String(error?.stdout || '').trim();
+          const combined = `${stdout}\n${stderr}`.trim();
+          openclaw.steps.push({ step: 'channels login whatsapp', ok: false, command: loginCommand, output: combined || error.message });
+        }
+      }
+    }
+
+    const failed = openclaw.steps.find((s) => !s.ok);
+    openclaw.details = failed ? failed.output : 'OpenClaw agent scaffold + registration OK';
+  }
+
+  return {
+    ok: true,
+    action: 'openclaw:init',
+    agent: safeName,
+    output_dir: agentDir,
+    files: ['SOUL.md', 'HEARDBEAT.md', 'CHANNELS.md', 'skills/citaspro/SKILL.md'],
+    skill_path: path.join(skillDir, 'SKILL.md'),
+    channels_path: path.join(agentDir, 'CHANNELS.md'),
+    prompt_source: '/api/prompts-and-templates',
+    prompt_preview: promptConfig.prompt,
+    tone: promptConfig.tone,
+    template: promptConfig.templateName || null,
+    whatsapp,
+    openclaw,
+  };
+}
+
+function printHeader(title) {
+  console.log(`\n${bold(colorize(title, 'yellow'))}`);
+  console.log(colorize('-'.repeat(title.length), 'gray'));
+}
+
+function printJson(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+
+function outputResult(data, asJson) {
+  if (asJson) {
+    printJson(data);
+  }
+}
+
+function extractErrorMessage(error) {
+  const responseData = error?.response?.data;
+  if (responseData?.details) {
+    return responseData.details;
+  }
+  if (responseData?.error) {
+    return responseData.error;
+  }
+  if (responseData) {
+    return JSON.stringify(responseData);
+  }
+  if (error?.message && error.message !== error?.name) {
+    return error.message;
+  }
+  if (Array.isArray(error?.errors) && error.errors.length > 0) {
+    return error.errors.map((e) => e?.message || String(e)).join('; ');
+  }
+  if (error?.code) {
+    return `${error?.name || 'Error'}:${error.code}`;
+  }
+  return error?.name || String(error) || 'Comando fallido';
+}
+
+function printList(rows, columns) {
+  if (!Array.isArray(rows) || rows.length === 0) {
+    console.log('Sin resultados.');
+    return;
+  }
+
+  const mapped = rows.map((row) => {
+    const out = {};
+    columns.forEach((col) => {
+      out[col.label] = row[col.key] ?? '';
+    });
+    return out;
+  });
+
+  console.table(mapped);
+}
+
+function wait(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function openBrowser(url) {
+  const platform = process.platform;
+  const command = platform === 'darwin'
+    ? `open "${url}"`
+    : platform === 'win32'
+      ? `start "" "${url}"`
+      : `xdg-open "${url}"`;
+
+  exec(command, (error) => {
+    if (error) {
+      console.log(`No se pudo abrir navegador automáticamente. Abre manualmente: ${url}`);
+    }
+  });
+}
+
+async function loginInteractive() {
+  const code = await post('/api/device/code', { client_id: 'citaspro-cli', scope: 'tools:all' });
+
+  console.log('\nInicia sesión para vincular este CLI:\n');
+  console.log(`Código: ${code.user_code}`);
+  console.log(`URL:    ${code.verification_uri_complete}`);
+
+  openBrowser(code.verification_uri_complete);
+  console.log(`\n${colorize('Esperando aprobación en navegador...', 'yellow')}\n`);
+
+  const expiresAt = Date.now() + (Number(code.expires_in || 900) * 1000);
+  const intervalMs = Number(code.interval || 5) * 1000;
+
+  while (Date.now() < expiresAt) {
+    try {
+      const token = await post('/api/device/token', {
+        grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
+        device_code: code.device_code,
+      });
+
+      const session = {
+        ...token,
+        api_base: API_BASE,
+        created_at: new Date().toISOString(),
+      };
+
+      writeSession(session);
+      console.log(colorize('Login successful. CLI autenticado.', 'green'));
+      console.log(`${colorize('Sesión guardada en:', 'gray')} ${AUTH_FILE}`);
+      return;
+    } catch (error) {
+      const apiError = error?.response?.data?.error;
+      if (apiError === 'authorization_pending' || apiError === 'slow_down') {
+        await wait(intervalMs);
+        continue;
+      }
+      if (apiError === 'expired_token') {
+        throw new Error('El código expiró. Ejecuta login de nuevo.');
+      }
+      throw new Error(error?.response?.data?.error_description || error?.response?.data?.error || error.message);
+    }
+  }
+
+  throw new Error('Timeout esperando aprobación. Ejecuta login nuevamente.');
+}
+
+function resolveTokenAndArgs(args) {
+  if (args.length > 0 && looksLikePayload(args[0])) {
+    const session = readSession();
+    if (!session?.access_token) {
+      throw new Error('No hay sesión. Ejecuta: node tools/citas-cli.js login');
+    }
+    return { token: session.access_token, rest: args };
+  }
+
+  if (args.length > 0 && looksLikeToken(args[0])) {
+    return { token: args[0], rest: args.slice(1) };
+  }
+
+  const session = readSession();
+  if (!session?.access_token) {
+    throw new Error('No hay sesión. Ejecuta: node tools/citas-cli.js login');
+  }
+
+  return { token: session.access_token, rest: args };
+}
+
+async function main() {
+  const [, , rawCmd, ...rawArgs] = process.argv;
+  const jsonMode = rawArgs.includes('--json');
+  const openclawFlagIndex = rawArgs.indexOf('--openclaw');
+  const whatsappFlagEnabled = rawArgs.includes('--whatsapp');
+  const openclawNameFromFlag = openclawFlagIndex >= 0
+    ? rawArgs[openclawFlagIndex + 1] && !rawArgs[openclawFlagIndex + 1].startsWith('--')
+      ? rawArgs[openclawFlagIndex + 1]
+      : 'nombreagente'
+    : null;
+  const argsWithoutFlags = rawArgs.filter((arg, idx) => {
+    if (arg === '--json') return false;
+    if (arg === '--openclaw') return false;
+    if (arg === '--whatsapp') return false;
+    if (openclawFlagIndex >= 0 && idx === openclawFlagIndex + 1 && !arg.startsWith('--')) return false;
+    return true;
+  });
+  let cmd = rawCmd;
+  let args = argsWithoutFlags;
+
+  if (!cmd && openclawNameFromFlag) {
+    cmd = 'openclaw:init';
+    args = [openclawNameFromFlag];
+  }
+
+  if (!cmd || cmd === 'help' || cmd === '--help' || cmd === '-h') {
+    usage();
+    process.exit(0);
+  }
+
+  // Alias layer (compatible con futuros comandos tipo "citasproctl leads ls")
+  if (cmd === 'get') {
+    cmd = 'leads:get';
+  } else if (cmd === 'ls') {
+    cmd = 'leads:list';
+  } else if (cmd === 'openclaw') {
+    cmd = 'openclaw:init';
+  } else if (cmd === 'leads' && args[0] === 'ls') {
+    cmd = 'leads:list';
+    args = args.slice(1);
+  } else if (cmd === 'leads' && args[0] === 'get') {
+    cmd = 'leads:get';
+    args = args.slice(1);
+  } else if (cmd === 'leads' && (args[0] === 'add' || args[0] === 'create')) {
+    cmd = 'leads:create';
+    args = args.slice(1);
+  } else if (cmd === 'bookings' && args[0] === 'ls') {
+    cmd = 'bookings:list';
+    args = args.slice(1);
+  } else if (cmd === 'bookings' && (args[0] === 'mv' || args[0] === 'reschedule')) {
+    cmd = 'bookings:reschedule';
+    args = args.slice(1);
+  } else if (cmd === 'bookings' && (args[0] === 'rm' || args[0] === 'cancel')) {
+    cmd = 'tools:cancel-booking';
+    args = args.slice(1);
+  } else if (cmd === 'calendar' && (args[0] === 'avail' || args[0] === 'availability')) {
+    cmd = 'tools:availability';
+    args = args.slice(1);
+  } else if (cmd === 'calendar' && args[0] === 'caldav') {
+    cmd = 'tools:caldav';
+    args = args.slice(1);
+  } else if (cmd === 'call') {
+    cmd = 'tools:call';
+  }
+
+  try {
+    if (cmd === '--openclaw') {
+      cmd = 'openclaw:init';
+      args = [args[0] || openclawNameFromFlag || 'nombreagente'];
+    }
+
+    if (cmd === 'ai:manifest') {
+      printJson(AI_MANIFEST);
+      return;
+    }
+
+    if (cmd === 'openclaw:init') {
+      const candidate = args[0] || openclawNameFromFlag || 'nombreagente';
+      const { token } = resolveTokenAndArgs([]);
+      const data = await createOpenClawSubagent(candidate, token, {
+        whatsapp: whatsappFlagEnabled,
+      });
+      if (jsonMode) {
+        printJson(data);
+        return;
+      }
+      printHeader('Subagente OpenClaw creado');
+      console.log(`Agente:      ${data.agent}`);
+      console.log(`Directorio:  ${data.output_dir}`);
+      console.log(`Archivos:    ${data.files.join(', ')}`);
+      console.log(`Prompt base: ${data.prompt_preview}`);
+      if (data.whatsapp?.enabled) {
+        console.log(`WhatsApp:    enabled (account=${data.whatsapp.account}, allow_all=true)`);
+      }
+      return;
+    }
+
+    if (cmd === 'login') {
+      await loginInteractive();
+      outputResult({ ok: true, message: 'login_successful', auth_file: AUTH_FILE }, jsonMode);
+      return;
+    }
+
+    if (cmd === 'logout') {
+      clearSession();
+      if (jsonMode) {
+        printJson({ ok: true, message: 'logout_successful' });
+      } else {
+        console.log(colorize('Sesión eliminada.', 'green'));
+      }
+      return;
+    }
+
+    if (cmd === 'whoami') {
+      const { token } = resolveTokenAndArgs(args);
+      const data = await post('/api/tools/auth.whoami', {}, token);
+      if (jsonMode) {
+        printJson(data);
+        return;
+      }
+      printHeader('Sesion actual');
+      console.log(`Usuario: ${data?.user?.nombre || '-'}`);
+      console.log(`Email:   ${data?.user?.email || '-'}`);
+      console.log(`User ID: ${data?.user?.id || '-'}`);
+      console.log(`Tenant:  ${data?.tenant_id || '-'}`);
+      console.log(`Auth:    ${data?.auth_type || '-'}`);
+      return;
+    }
+
+    if (cmd === 'device:start') {
+      const data = await post('/api/device/code', { client_id: 'citaspro-cli', scope: 'tools:all' });
+      printJson(data);
+      return;
+    }
+
+    if (cmd === 'device:poll') {
+      const deviceCode = args[0];
+      if (!deviceCode) {
+        throw new Error('Falta device_code');
+      }
+
+      const data = await post('/api/device/token', {
+        grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
+        device_code: deviceCode,
+      });
+      printJson(data);
+      return;
+    }
+
+    if (cmd === 'tools:availability') {
+      const { token, rest } = resolveTokenAndArgs(args);
+      const [fecha, hora_inicio, hora_fin] = rest;
+      if (!fecha || !hora_inicio || !hora_fin) {
+        throw new Error('Uso: tools:availability <fecha> <hora_inicio> <hora_fin>');
+      }
+      const data = await post('/api/tools/calendar.getAvailability', { fecha, hora_inicio, hora_fin }, token);
+      if (jsonMode) {
+        printJson(data);
+        return;
+      }
+      printHeader('Disponibilidad');
+      console.log(`Disponible: ${data.available ? 'SI' : 'NO'}`);
+      console.log(`Festivo:    ${data?.reasons?.is_holiday ? 'SI' : 'NO'}`);
+      console.log(`Jornada:    ${data?.reasons?.outside_working_hours ? 'Fuera' : 'Dentro'}`);
+      console.log(`Conflictos: ${data?.reasons?.conflicts_count ?? 0}`);
+      if (Array.isArray(data.conflicts) && data.conflicts.length > 0) {
+        printList(data.conflicts, [
+          { key: 'id', label: 'ID' },
+          { key: 'fecha', label: 'Fecha' },
+          { key: 'hora_inicio', label: 'Inicio' },
+          { key: 'hora_fin', label: 'Fin' },
+          { key: 'contacto_nombre', label: 'Contacto' },
+        ]);
+      }
+      return;
+    }
+
+    if (cmd === 'leads:list') {
+      const { token, rest } = resolveTokenAndArgs(args);
+      const [limitRaw] = rest;
+      const limit = limitRaw ? Number(limitRaw) : 20;
+      const data = await post('/api/tools/crm.listLeads', { limit }, token);
+      if (jsonMode) {
+        printJson(data);
+        return;
+      }
+      printHeader(`Leads (${data.count || 0})`);
+      printList(data.leads || [], [
+        { key: 'id', label: 'ID' },
+        { key: 'nombre', label: 'Nombre' },
+        { key: 'email', label: 'Email' },
+        { key: 'telefono', label: 'Telefono' },
+        { key: 'estado', label: 'Estado' },
+        { key: 'fecha_creacion', label: 'Creado' },
+      ]);
+      return;
+    }
+
+    if (cmd === 'leads:get') {
+      const { token, rest } = resolveTokenAndArgs(args);
+      const [identifier] = rest;
+      if (!identifier) {
+        throw new Error('Uso: leads:get [token] <lead_id|email|phone>');
+      }
+
+      const payload = identifier.includes('@')
+        ? { email: identifier }
+        : /^[0-9+\s()-]+$/.test(identifier)
+          ? { telefono: identifier.replace(/\s+/g, '') }
+          : { lead_id: identifier };
+
+      const data = await post('/api/tools/crm.getLead', payload, token);
+      if (jsonMode) {
+        printJson(data);
+        return;
+      }
+      printHeader('Lead');
+      printJson(data.lead || data);
+      return;
+    }
+
+    if (cmd === 'leads:create') {
+      const { token, rest } = resolveTokenAndArgs(args);
+      const [payloadRaw] = rest;
+      if (!payloadRaw) {
+        throw new Error('Uso: leads:create <json_payload>');
+      }
+      const payload = JSON.parse(payloadRaw);
+      const data = await post('/api/tools/crm.createLead', payload, token);
+      if (jsonMode) {
+        printJson(data);
+        return;
+      }
+      printHeader('Lead creado');
+      printJson(data.lead || data);
+      return;
+    }
+
+    if (cmd === 'bookings:list') {
+      const { token, rest } = resolveTokenAndArgs(args);
+      const [limitRaw] = rest;
+      const limit = limitRaw ? Number(limitRaw) : 20;
+      const data = await post('/api/tools/calendar.listBookings', { limit }, token);
+      if (jsonMode) {
+        printJson(data);
+        return;
+      }
+      printHeader(`Reservas (${data.count || 0})`);
+      printList(data.bookings || [], [
+        { key: 'id', label: 'ID' },
+        { key: 'fecha', label: 'Fecha' },
+        { key: 'hora_inicio', label: 'Inicio' },
+        { key: 'hora_fin', label: 'Fin' },
+        { key: 'contacto_nombre', label: 'Contacto' },
+        { key: 'estado', label: 'Estado' },
+      ]);
+      return;
+    }
+
+    if (cmd === 'bookings:reschedule') {
+      const { token, rest } = resolveTokenAndArgs(args);
+      const [bookingId, fecha, hora_inicio, hora_fin] = rest;
+      if (!bookingId || !fecha || !hora_inicio || !hora_fin) {
+        throw new Error('Uso: bookings:reschedule <booking_id> <fecha> <hora_inicio> <hora_fin>');
+      }
+      const data = await post('/api/tools/calendar.rescheduleBooking', {
+        booking_id: bookingId,
+        fecha,
+        hora_inicio,
+        hora_fin,
+      }, token);
+      if (jsonMode) {
+        printJson(data);
+        return;
+      }
+      printHeader('Reserva reprogramada');
+      printJson(data.booking || data);
+      return;
+    }
+
+    if (cmd === 'tools:create-booking') {
+      const { token, rest } = resolveTokenAndArgs(args);
+      const [payloadRaw] = rest;
+      if (!payloadRaw) {
+        throw new Error('Uso: tools:create-booking <json_payload>');
+      }
+      const payload = JSON.parse(payloadRaw);
+      const data = await post('/api/tools/calendar.createBooking', payload, token);
+      if (jsonMode) {
+        printJson(data);
+        return;
+      }
+      printHeader('Reserva creada');
+      printJson(data.booking || data);
+      return;
+    }
+
+    if (cmd === 'tools:cancel-booking') {
+      const { token, rest } = resolveTokenAndArgs(args);
+      const [bookingId] = rest;
+      if (!bookingId) {
+        throw new Error('Uso: tools:cancel-booking <booking_id>');
+      }
+      const data = await post('/api/tools/calendar.cancelBooking', { booking_id: bookingId }, token);
+      if (jsonMode) {
+        printJson(data);
+        return;
+      }
+      printHeader('Reserva cancelada');
+      printJson(data.booking || data);
+      return;
+    }
+
+    if (cmd === 'tools:caldav') {
+      const { token } = resolveTokenAndArgs(args);
+      const data = await post('/api/tools/calendar.getCaldavLink', {}, token);
+      if (jsonMode) {
+        printJson(data);
+        return;
+      }
+      printHeader('CalDAV');
+      console.log(`URL: ${data.caldav_url || 'No disponible'}`);
+      console.log(`Usuario Radicale: ${data.radicale_username || '-'}`);
+      console.log(`Calendar ID:      ${data.calendar_id || '-'}`);
+      return;
+    }
+
+    if (cmd === 'tools:call') {
+      const { token, rest } = resolveTokenAndArgs(args);
+      const [to, message] = rest;
+      if (!to) {
+        throw new Error('Uso: tools:call <to> [message]');
+      }
+      const data = await post('/api/tools/calls.placeCall', { to, message: message || 'Llamada de prueba desde CLI' }, token);
+      if (jsonMode) {
+        printJson(data);
+        return;
+      }
+      printHeader('Llamada');
+      printJson(data);
+      return;
+    }
+
+    usage();
+    process.exit(1);
+  } catch (error) {
+    const message = extractErrorMessage(error);
+    if (jsonMode) {
+      printJson({ ok: false, error: message });
+    } else {
+      console.error(`${colorize('Error:', 'red')} ${message}`);
+    }
+    process.exit(1);
+  }
+}
+
+main();

package/package.json

@@ -0,0 +1,23 @@
+{
+  "$schema": "https://json.schemastore.org/package",
+  "name": "citaspro-cli",
+  "version": "1.0.2",
+  "description": "CLI para gestionar leads, reservas y calendario de CitasPro",
+  "bin": {
+    "citaspro-cli": "citasproctl.js"
+  },
+  "type": "commonjs",
+  "preferGlobal": true,
+  "files": [
+    "citasproctl.js",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "axios": "^1.7.7",
+    "dotenv": "^16.0.3"
+  },
+  "license": "ISC"
+}