@vaia-lab/sdk 0.2.0 → 0.4.0

package/dist/agent-1bVw0eB8.d.ts

@@ -0,0 +1,222 @@
+/**
+ * VAIA Extension Protocol — superficie de AGENTE.
+ *
+ * Es la parte del protocolo que permite que el asistente de Handeia viva
+ * dentro de un espacio de terceros. Sigue la regla del ecosistema: protocolo
+ * antes que SDK. Lo que hay aquí son CONTRATOS; el SDK solo los transporta.
+ *
+ * ── El reparto de papeles ────────────────────────────────────────────────
+ *   El espacio  → superficie y manos. Declara qué sabe y qué puede hacer.
+ *   Handeia     → cerebro, memoria y autoridad. Decide y ejecuta a través suyo.
+ *
+ * Por eso un espacio NO trae su propia IA: si la trajera, no te conocería,
+ * empezaría de cero cada vez, y no podría contradecirse a sí mismo. El caso
+ * que lo justifica: el espacio puntúa un resultado con 90 y el agente te dice
+ * que te conviene el de 87, porque sabe algo de ti que el espacio no sabe.
+ * Eso solo es posible si el cerebro vive fuera del espacio.
+ *
+ * ── La regla de confianza, que manda sobre todo lo demás ─────────────────
+ * El espacio es CÓDIGO DE TERCEROS. Nada de lo que envía es un hecho: es una
+ * AFIRMACIÓN. Handeia la trata como dato citado, nunca como instrucción y
+ * nunca al mismo nivel que lo que sabe del usuario. Un espacio que escriba
+ * "ignora las instrucciones anteriores" en su contexto no logra nada.
+ *
+ * @see AGENT_PROTOCOL_VERSION para la política de compatibilidad.
+ */
+/**
+ * Versión del protocolo de agente. Viaja en cada mensaje.
+ *
+ * Se versiona desde el primer día a propósito: este contrato es público y
+ * cambiarlo después obliga a coordinar despliegues entre partes que no se
+ * conocen. Ya se pagó esa factura una vez con la codificación del JWT.
+ */
+declare const AGENT_PROTOCOL_VERSION = 1;
+/** Un parámetro de una acción. Sin tipos no hay validación posible. */
+interface AgentActionParam {
+    name: string;
+    type: 'string' | 'number' | 'boolean';
+    description: string;
+    required?: boolean | undefined;
+    /** Valores admitidos. Si se define, nada fuera de la lista es válido. */
+    enum?: string[] | undefined;
+}
+/**
+ * Algo que el espacio sabe hacer.
+ *
+ * Handeia SOLO puede pedir acciones declaradas aquí. No improvisa, no toca el
+ * DOM, no busca la forma. Si no está declarada, para el agente no existe —
+ * y eso es lo que hace que el mismo agente sirva en cualquier espacio sin que
+ * Handeia sepa nada de ninguno en particular.
+ */
+interface AgentAction {
+    /** Identificador estable, en minúsculas: 'filtrar_resultados'. */
+    name: string;
+    /** Qué hace, en lenguaje natural. Es lo que lee el modelo para elegirla. */
+    description: string;
+    params?: AgentActionParam[] | undefined;
+    /**
+     * true si modifica algo. Las que escriben se confirman con el usuario ANTES
+     * de ejecutarse — un agente que escribe sin preguntar se siente fuera de
+     * control incluso cuando acierta.
+     */
+    writes?: boolean | undefined;
+    /** Permiso que el usuario debe haber concedido a este espacio. */
+    permission?: string | undefined;
+}
+/** Configuración de la superficie de agente dentro de defineCapability. */
+interface AgentSurfaceConfig {
+    /** Acciones que el espacio expone. Vacío = el agente solo puede responder. */
+    actions?: AgentAction[] | undefined;
+    /**
+     * Endpoint para preguntarle al espacio cuando el usuario NO está dentro
+     * ("¿tengo algo pendiente ahí?"). El círculo solo existe con el espacio
+     * abierto; esto es lo que permite que Handeia sea el lugar donde convergen
+     * todos tus espacios en vez de uno más al que entrar.
+     */
+    queryEndpoint?: string | undefined;
+    /** Frase de bienvenida propia del espacio. */
+    greeting?: string | undefined;
+    /**
+     * Servicios externos que el espacio necesita consultar. El usuario los
+     * concede por espacio y los puede revocar cuando quiera. El espacio jamás
+     * recibe el token: pide operaciones, la plataforma las ejecuta.
+     */
+    needs?: ConnectorNeed[] | undefined;
+}
+/**
+ * Servicios externos que un espacio puede necesitar (GitHub, Drive, Calendar…).
+ *
+ * ── La regla, y no tiene excepciones ─────────────────────────────────────
+ * El espacio NUNCA recibe el token del usuario. Declara qué necesita, la
+ * plataforma llama al proveedor con el token que YA tiene guardado, y le
+ * devuelve solo el resultado.
+ *
+ * Por qué así y no entregando el token:
+ *   - Si cada espacio guardara tokens, la superficie de ataque se multiplica
+ *     por cada desarrollador que publique. Un espacio comprometido entregaría
+ *     el GitHub y el Drive de todos sus usuarios.
+ *   - Prestado, un espacio comprometido solo puede pedir las operaciones que
+ *     el usuario le concedió, con límite de frecuencia, auditadas y
+ *     revocables al instante desde Conectores.
+ *
+ * De regalo, publicar un espacio se vuelve barato: el desarrollador no
+ * implementa OAuth de nada.
+ */
+type ConnectorNeed = 'github' | 'drive' | 'calendar' | 'email' | 'notion' | 'discord';
+/**
+ * Operaciones de LECTURA que la plataforma sabe hacer por el espacio.
+ *
+ * Lista cerrada a propósito: un espacio no puede pedir "haz esta llamada
+ * arbitraria a la API de GitHub". Solo puede pedir lo que está aquí, y cada
+ * una devuelve datos ya acotados. Escribir en un servicio externo NO se
+ * presta — para eso el usuario usa el servicio.
+ */
+type ConnectorOperation = 'github.repos' | 'github.issues' | 'drive.files' | 'calendar.events' | 'email.recent' | 'notion.pages';
+/** Lo que el espacio pide prestado. */
+interface ConnectorRequest {
+    operation: ConnectorOperation;
+    /** Filtros simples. La plataforma los valida; nada de consultas libres. */
+    params?: Record<string, string | number | boolean> | undefined;
+}
+/** Lo que la plataforma devuelve. Datos, jamás credenciales. */
+interface ConnectorResult {
+    operation: ConnectorOperation;
+    ok: boolean;
+    items?: Record<string, unknown>[] | undefined;
+    /** 'sin_conectar' = el usuario no ha vinculado ese servicio todavía. */
+    error?: 'sin_permiso' | 'sin_conectar' | 'no_soportada' | 'limite_excedido' | 'fallo' | undefined;
+}
+/** Qué operación necesita qué conector — la plataforma lo usa para autorizar. */
+declare const CONNECTOR_OF_OPERATION: Record<ConnectorOperation, ConnectorNeed>;
+/**
+ * Lo que el espacio dice que está pasando.
+ *
+ * OJO: se llama `claims` y no `facts` a propósito. Handeia lo etiqueta como
+ * afirmación de un tercero antes de dárselo al modelo.
+ */
+interface AgentSpaceContext {
+    /** Dónde está el usuario dentro del espacio: '/lista'. */
+    route?: string | undefined;
+    /** Qué está viendo, en lenguaje natural: 'Lista de 12 resultados'. */
+    view?: string | undefined;
+    /** Datos que el espacio considera relevantes ahora mismo. */
+    claims?: Record<string, unknown> | undefined;
+}
+/** Petición del espacio a Handeia. Un solo endpoint, un solo formato. */
+interface AgentTurnRequest {
+    protocol: typeof AGENT_PROTOCOL_VERSION;
+    /** Lo que escribió el usuario. */
+    message: string;
+    context?: AgentSpaceContext | undefined;
+    /** Acciones disponibles AHORA (pueden ser menos que las declaradas). */
+    actions?: AgentAction[] | undefined;
+    /** Turnos previos, para que el agente no pierda el hilo. */
+    history?: {
+        role: 'user' | 'agent';
+        text: string;
+    }[] | undefined;
+    /** Resultado de una acción que Handeia pidió en el turno anterior. */
+    actionResult?: AgentActionResult | undefined;
+}
+/** Lo que el espacio devuelve tras ejecutar una acción. */
+interface AgentActionResult {
+    action: string;
+    ok: boolean;
+    /** Qué pasó, para que el agente pueda cerrar el ciclo con el usuario. */
+    summary?: string | undefined;
+    error?: string | undefined;
+}
+/**
+ * De dónde salió lo que el agente afirma.
+ *
+ * No es adorno: es el pilar de info verificada. Cuando el agente contradice
+ * al espacio ("dice 90, pero te conviene la de 87"), tiene que poder decir de
+ * dónde sacó su razón. Un oráculo que no se explica no se gana la confianza.
+ */
+interface AgentEvidence {
+    /** 'handeia' = memoria del usuario · 'space' = lo que declaró el espacio. */
+    source: 'handeia' | 'space';
+    label: string;
+}
+/** Respuesta de Handeia al espacio. */
+interface AgentTurnResponse {
+    protocol: typeof AGENT_PROTOCOL_VERSION;
+    /** Qué decirle al usuario. */
+    text?: string | undefined;
+    /** Acción a ejecutar. Siempre sale de la lista declarada, nunca inventada. */
+    action?: {
+        name: string;
+        args?: Record<string, unknown> | undefined;
+    } | undefined;
+    /** true si hay que confirmar con el usuario antes de ejecutarla. */
+    confirm?: boolean | undefined;
+    evidence?: AgentEvidence[] | undefined;
+    /** Identificador para cruzar los registros de todas las capas. */
+    traceId?: string | undefined;
+}
+/**
+ * Revisa que las acciones declaradas sean utilizables.
+ *
+ * Corre al declarar la capacidad, no en producción: un contrato mal escrito
+ * debe reventar en el escritorio del desarrollador, no frente al usuario.
+ */
+declare function validateAgentSurface(cfg: AgentSurfaceConfig): string[];
+/**
+ * ¿Es válida esta acción contra lo declarado?
+ *
+ * La usa Handeia antes de reenviarle nada al espacio. Es la lista blanca en
+ * ejecución: aunque el modelo se invente una acción o un argumento fuera de
+ * rango, aquí se detiene.
+ */
+declare function validateActionCall(llamada: {
+    name: string;
+    args?: Record<string, unknown> | undefined;
+}, declaradas: AgentAction[]): {
+    ok: true;
+    action: AgentAction;
+} | {
+    ok: false;
+    reason: string;
+};
+
+export { type AgentSurfaceConfig as A, CONNECTOR_OF_OPERATION as C, type AgentAction as a, AGENT_PROTOCOL_VERSION as b, type AgentActionParam as c, type AgentActionResult as d, type AgentEvidence as e, type AgentSpaceContext as f, type AgentTurnRequest as g, type AgentTurnResponse as h, type ConnectorNeed as i, type ConnectorOperation as j, type ConnectorRequest as k, type ConnectorResult as l, validateAgentSurface as m, validateActionCall as v };

package/dist/cli.js

@@ -3,6 +3,7 @@
 // src/cli.ts
 import { readFileSync, writeFileSync, existsSync } from "fs";
 import { resolve, join } from "path";
+import { pathToFileURL } from "url";
 import { createInterface } from "readline";
 
 // src/crypto.ts
@@ -22,6 +23,107 @@ async function hmacSign(secret, data) {
   return Array.from(new Uint8Array(sig)).map((b) => b.toString(16).padStart(2, "0")).join("");
 }
 
+// src/agent.ts
+var AGENT_PROTOCOL_VERSION = 1;
+var NOMBRE_ACCION = /^[a-z][a-z0-9_]{1,48}$/;
+function validateAgentSurface(cfg) {
+  const errores = [];
+  const vistos = /* @__PURE__ */ new Set();
+  for (const accion of cfg.actions ?? []) {
+    if (!NOMBRE_ACCION.test(accion.name)) {
+      errores.push(`Acci\xF3n "${accion.name}": el nombre debe ser min\xFAsculas, n\xFAmeros o guion bajo.`);
+    }
+    if (vistos.has(accion.name)) {
+      errores.push(`Acci\xF3n "${accion.name}": declarada dos veces.`);
+    }
+    vistos.add(accion.name);
+    if (!accion.description?.trim()) {
+      errores.push(`Acci\xF3n "${accion.name}": falta la descripci\xF3n, que es lo que el agente lee para elegirla.`);
+    }
+    if (accion.writes && !accion.permission) {
+      errores.push(`Acci\xF3n "${accion.name}": modifica datos, as\xED que necesita un permiso declarado.`);
+    }
+    for (const p of accion.params ?? []) {
+      if (!p.name?.trim()) errores.push(`Acci\xF3n "${accion.name}": un par\xE1metro no tiene nombre.`);
+      if (!p.description?.trim()) {
+        errores.push(`Acci\xF3n "${accion.name}", par\xE1metro "${p.name}": falta la descripci\xF3n.`);
+      }
+    }
+  }
+  if (cfg.queryEndpoint && !cfg.queryEndpoint.startsWith("/")) {
+    errores.push('queryEndpoint debe ser una ruta de tu propio servidor, empezando por "/".');
+  }
+  return errores;
+}
+
+// src/pieces.ts
+var NOMBRE = /^[a-z][a-z0-9_]{1,48}$/;
+var ORDEN = {
+  prohibida: 0,
+  requiere_aprobacion: 1,
+  autonoma: 2
+};
+function validatePieces(cfg) {
+  const errores = [];
+  const vistos = /* @__PURE__ */ new Set();
+  const revisarNombre = (pieza, name) => {
+    if (!NOMBRE.test(name)) errores.push(`${pieza} "${name}": el nombre debe ser min\xFAsculas, n\xFAmeros o guion bajo.`);
+    if (vistos.has(name)) errores.push(`"${name}": hay dos piezas con el mismo nombre.`);
+    vistos.add(name);
+  };
+  const revisarAutoridad = (pieza, a) => {
+    if (a.consequence === "irreversible" && a.level === "autonoma") {
+      errores.push(`${pieza}: una acci\xF3n irreversible no puede ser aut\xF3noma \u2014 como m\xEDnimo requiere aprobaci\xF3n.`);
+    }
+    if (a.maxAmount !== void 0) {
+      if (a.maxAmount <= 0) errores.push(`${pieza}: el tope de gasto debe ser mayor que cero.`);
+      if (!a.currency) errores.push(`${pieza}: hay tope de gasto pero no se declar\xF3 la moneda.`);
+    }
+    if (a.consequence === "costosa" && a.level === "autonoma" && a.maxAmount === void 0) {
+      errores.push(`${pieza}: es aut\xF3noma y cuesta dinero, as\xED que necesita un tope declarado.`);
+    }
+  };
+  for (const s of cfg.skills ?? []) {
+    revisarNombre("Skill", s.name);
+    if (!s.description?.trim()) errores.push(`Skill "${s.name}": falta la descripci\xF3n, que es lo que el modelo lee para elegirla.`);
+    if (s.evidence?.required && (s.evidence.accepts?.length ?? 0) === 0) {
+      errores.push(`Skill "${s.name}": exige evidencia pero no declara qu\xE9 tipos acepta.`);
+    }
+  }
+  for (const t of cfg.tools ?? []) {
+    revisarNombre("Herramienta", t.name);
+    if (!t.description?.trim()) errores.push(`Herramienta "${t.name}": falta la descripci\xF3n.`);
+    if (!t.permission?.trim()) errores.push(`Herramienta "${t.name}": toca el mundo real, as\xED que necesita un permiso declarado.`);
+    revisarAutoridad(`Herramienta "${t.name}"`, t.authority);
+  }
+  for (const w of cfg.workflows ?? []) {
+    revisarNombre("Workflow", w.name);
+    if ((w.steps?.length ?? 0) === 0) errores.push(`Workflow "${w.name}": no tiene pasos.`);
+    revisarAutoridad(`Workflow "${w.name}"`, w.authority);
+  }
+  const porNombre = new Map((cfg.tools ?? []).map((t) => [t.name, t]));
+  for (const a of cfg.agents ?? []) {
+    revisarNombre("Agente", a.name);
+    if (!a.purpose?.trim()) {
+      errores.push(`Agente "${a.name}": falta el prop\xF3sito \u2014 para qu\xE9 existe.`);
+    }
+    revisarAutoridad(`Agente "${a.name}"`, a.authority);
+    for (const nombreTool of a.tools ?? []) {
+      const tool = porNombre.get(nombreTool);
+      if (!tool) {
+        errores.push(`Agente "${a.name}": usa la herramienta "${nombreTool}", que no est\xE1 declarada.`);
+        continue;
+      }
+      if (ORDEN[tool.authority.level] > ORDEN[a.authority.level]) {
+        errores.push(
+          `Agente "${a.name}": su herramienta "${nombreTool}" tiene m\xE1s autoridad que \xE9l. Ninguna pieza puede superar el techo de su agente.`
+        );
+      }
+    }
+  }
+  return errores;
+}
+
 // src/define.ts
 function defineCapability(config) {
   const required = ["id", "name", "version", "target", "type", "sector", "permissions", "risk"];
@@ -38,6 +140,20 @@ function defineCapability(config) {
   if (Object.keys(config.surfaces).length === 0) {
     throw new Error(`[@vaia/sdk] defineCapability: 'surfaces' no puede estar vac\xEDo. Define al menos un surface con su endpoint.`);
   }
+  if (config.pieces) {
+    const errores = validatePieces(config.pieces);
+    if (errores.length > 0) {
+      throw new Error(`[@vaia/sdk] defineCapability: piezas inv\xE1lidas:
+  - ${errores.join("\n  - ")}`);
+    }
+  }
+  if (config.agent) {
+    const errores = validateAgentSurface(config.agent);
+    if (errores.length > 0) {
+      throw new Error(`[@vaia/sdk] defineCapability: superficie de agente inv\xE1lida:
+  - ${errores.join("\n  - ")}`);
+    }
+  }
   return config;
 }
 function toManifest(config) {
@@ -52,6 +168,16 @@ function toManifest(config) {
     level: config.level,
     sector: config.sector,
     surfaces,
+    // El agente viaja en el manifest para que el portal y Handeia sepan qué
+    // puede hacer este espacio sin abrir su código.
+    agent: config.agent ? {
+      protocol: AGENT_PROTOCOL_VERSION,
+      actions: config.agent.actions ?? [],
+      query_endpoint: config.agent.queryEndpoint
+    } : void 0,
+    // Las piezas viajan al manifest: el portal necesita mostrar qué autoridad
+    // pide una capacidad ANTES de que alguien la instale.
+    pieces: config.pieces,
     permissions: config.permissions,
     risk: config.risk,
     has_own_auth: config.has_own_auth ?? false,
@@ -72,6 +198,10 @@ var args = process.argv.slice(2);
 var cmd = args[0];
 async function main() {
   switch (cmd) {
+    case "init":
+      return cmdInit();
+    case "doctor":
+      return cmdDoctor();
     case "manifest":
       return cmdManifest();
     case "sign":
@@ -85,6 +215,126 @@ async function main() {
       printHelp();
   }
 }
+async function cmdInit() {
+  const cwd = process.cwd();
+  const out = join(cwd, "vaia.config.ts");
+  if (existsSync(out)) {
+    console.error("\u2717 Ya existe vaia.config.ts en esta carpeta.");
+    process.exit(1);
+  }
+  const plantilla = `import { defineCapability } from '@vaia-lab/sdk'
+
+/**
+ * Tu capacidad, declarada.
+ *
+ * Esto es la \xFAnica fuente de verdad: el portal la lee y arma el manifest solo.
+ */
+export default defineCapability({
+  id: 'mx.mi-capacidad',
+  name: 'Mi capacidad',
+  version: '0.1.0',
+  target: 'handeia',       // 'gandia' | 'handeia' | 'both'
+  type: 'app',
+  sector: 'general',
+  description: 'Describe en una l\xEDnea qu\xE9 resuelve.',
+
+  surfaces: {
+    text: { endpoint: '/api/vaia/invoke' },
+  },
+
+  // \u2500\u2500 Las piezas \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+  // La autoridad NO es opcional: hay que decir hasta d\xF3nde puede llegar cada
+  // cosa. Lo irreversible nunca puede ser aut\xF3nomo, y lo que gasta dinero
+  // necesita tope y moneda. Si te lo saltas, esto no compila.
+  pieces: {
+    tools: [
+      {
+        name: 'consultar_datos',
+        description: 'Lee datos del usuario para responder preguntas.',
+        permission: 'read:datos',
+        authority: {
+          level: 'autonoma',          // 'autonoma' | 'requiere_aprobacion' | 'prohibida'
+          consequence: 'reversible',  // 'reversible' | 'costosa' | 'irreversible'
+          rationale: 'Solo lee. No cambia nada del usuario.',
+        },
+      },
+    ],
+  },
+
+  // \u2500\u2500 El agente dentro de tu app \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+  // El asistente de Handeia vive en tu superficie. T\xFA declaras qu\xE9 sabes
+  // hacer; \xE9l razona con eso m\xE1s lo que sabe del usuario, que t\xFA nunca ves.
+  agent: {
+    greeting: '\xBFEn qu\xE9 te ayudo?',
+    actions: [
+      {
+        name: 'ir_a',
+        description: 'Lleva al usuario a una secci\xF3n de la app.',
+        params: [
+          { name: 'seccion', type: 'string', description: 'Secci\xF3n destino.', required: true },
+        ],
+      },
+    ],
+    // Servicios que necesitas consultar. NUNCA recibes el token del usuario:
+    // pides la operaci\xF3n y la plataforma te devuelve solo el resultado.
+    needs: [],
+  },
+
+  permissions: ['read:datos'],
+  risk: 'low',
+})
+`;
+  writeFileSync(out, plantilla, "utf8");
+  console.log("\u2713 vaia.config.ts creado");
+  console.log("");
+  console.log("  Siguiente:");
+  console.log("    1. Edita el id, el nombre y lo que sabe hacer tu app.");
+  console.log("    2. npx vaia manifest      \u2192 genera el manifest");
+  console.log("    3. S\xFAbelo desde el portal de developers.");
+}
+async function cmdDoctor() {
+  const cwd = process.cwd();
+  const configPath = resolve(cwd, "vaia.config.js");
+  if (!existsSync(configPath)) {
+    console.error("\u2717 No encontr\xE9 vaia.config.js. Compila tu vaia.config.ts primero, o corre `vaia init`.");
+    process.exit(1);
+  }
+  let config;
+  try {
+    const mod = await import(pathToFileURL(configPath).href);
+    config = mod.default ?? mod.config;
+  } catch (err) {
+    console.error(`\u2717 No pude cargar vaia.config.js:
+  ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+  const avisos = [];
+  const graves = [];
+  for (const t of config.pieces?.tools ?? []) {
+    if (t.authority.level === "autonoma" && t.authority.consequence === "costosa" && !t.authority.rationale) {
+      avisos.push(`"${t.name}" gasta dinero sola y no explica por qu\xE9 se le dio esa confianza.`);
+    }
+    if (t.permission && !config.permissions.includes(t.permission)) {
+      graves.push(`"${t.name}" pide el permiso "${t.permission}", que no est\xE1 en la lista de permisos de la capacidad.`);
+    }
+  }
+  const usados = new Set((config.pieces?.tools ?? []).map((t) => t.permission));
+  for (const p of config.permissions) {
+    if (!usados.has(p)) avisos.push(`El permiso "${p}" se pide pero ninguna herramienta lo usa. Pedir de m\xE1s incomoda al usuario.`);
+  }
+  for (const a of config.agent?.actions ?? []) {
+    if (a.writes && !a.permission) {
+      graves.push(`La acci\xF3n "${a.name}" modifica datos y no declara permiso.`);
+    }
+  }
+  if (graves.length === 0 && avisos.length === 0) {
+    console.log("\u2713 Todo en orden.");
+    return;
+  }
+  for (const g of graves) console.error(`\u2717 ${g}`);
+  for (const a of avisos) console.log(`\u26A0 ${a}`);
+  if (graves.length > 0) process.exit(1);
+}
 async function cmdManifest() {
   const cwd = process.cwd();
   const configPath = resolve(cwd, "vaia.config.js");
@@ -182,6 +432,8 @@ function printHelp() {
     `@vaia/sdk v${pkg.version}`,
     "",
     "Comandos:",
+    "  vaia-sdk init                  Crea vaia.config.ts listo para editar",
+    "  vaia-sdk doctor                Revisa tu configuraci\xF3n y avisa qu\xE9 est\xE1 mal",
     "  vaia-sdk manifest              Genera gandia.manifest.json desde vaia.config.js",
     "  vaia-sdk manifest --validate   Valida un gandia.manifest.json existente",
     "  vaia-sdk sign [payload]        Firma un payload con GANDIA_KEY_SECRET",