@layerall/cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sidarta Veloso
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,63 @@
+# @layerall/cli
+
+CLI tool for scaffolding LayerAll policies and validating them.
+
+## Install
+
+```bash
+npm install -g @layerall/cli
+# or
+npx @layerall/cli <command>
+```
+
+## Commands
+
+### `layerall init`
+
+Scaffolds a `layerall.policy.json` with sensible defaults covering all four operations.
+
+```bash
+layerall init -p providerA,providerB,providerC -w providerA=50,providerB=30,providerC=20 -o layerall.policy.json
+```
+
+### `layerall validate <file>`
+
+Validates the shape of a policy document and reports issues.
+
+```bash
+layerall validate layerall.policy.json
+```
+
+### `layerall init-landing`
+
+Generates a static marketing landing page (`index.html`) from a JSON config describing
+the product, providers, strategies, pricing and SDK snippets. With no `--config`,
+emits a brandable agnostic "AllX" template.
+
+```bash
+layerall init-landing --config allgeo.json --out landing-geo
+layerall init-landing --out landing-default
+```
+
+Schema:
+
+```jsonc
+{
+  "product": "AllGeo",                     // required
+  "tagline": "Geocode reverso unificado", // required
+  "domain": "geocode reverso",            // required
+  "operations": ["reverse", "batch"],      // required
+  "strategies": ["round_robin", "most_fast", "failover"], // required
+  "providers": [                            // required (≥1)
+    { "name": "Google Maps", "weight": 50, "latency": 180, "health": 0.98 }
+  ],
+  "sdkExamples": { /* "node" | "python" | "curl": "..." */ }, // optional
+  "pricing":   { /* "<tier>": { "price": "...", "requests": "...", "providers": number | "ilimitado", "features": ["..."] } */ }, // optional
+  "cta":       { "email": "geo@allx.com" }  // optional
+}
+```
+
+The generated HTML is fully static (Tailwind CDN + Google Fonts, no build step) and
+can be hosted on any CDN.
+
+See the root [README](../../README.md).

package/dist/chunk-WDABYCHT.js

@@ -0,0 +1,204 @@
+// src/policy.ts
+var ALL_OPS = ["create", "send", "status", "cancel"];
+var STRATEGIES_PER_OP = {
+  create: "round_robin",
+  send: "load_balance",
+  status: "most_fast",
+  cancel: "failover"
+};
+function buildPolicy(opts) {
+  const providers = opts.providers.slice();
+  const failures = { max: opts.retries?.max ?? 1, backoffMs: opts.retries?.backoffMs ?? 300 };
+  const operations = {};
+  for (const op of ALL_OPS) {
+    const strategy = STRATEGIES_PER_OP[op];
+    operations[op] = {
+      strategy,
+      timeoutMs: opts.timeoutMs ?? 8e3,
+      retries: failures,
+      failover: strategy === "failover",
+      ...opts.weights ? { weights: opts.weights } : {}
+    };
+  }
+  return { tenants: { default: { providers, operations } } };
+}
+function validatePolicy(policy) {
+  const issues = [];
+  if (!policy || typeof policy !== "object") return ["policy must be an object"];
+  const root = policy;
+  if (!root.tenants || typeof root.tenants !== "object") issues.push("missing tenants map");
+  for (const [tenant, value] of Object.entries(root.tenants ?? {})) {
+    const t = value;
+    if (!Array.isArray(t.providers)) issues.push(`tenant "${tenant}" providers must be an array`);
+    if (!t.operations || typeof t.operations !== "object")
+      issues.push(`tenant "${tenant}" operations must be an object`);
+  }
+  return issues;
+}
+
+// src/landing.ts
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var TEMPLATE_PATH = join(__dirname, "templates", "landing.html");
+var STRATEGY_NAMES = ["round_robin", "load_balance", "most_fast", "failover"];
+var VALID_STRATEGIES = new Set(STRATEGY_NAMES);
+function validateLandingConfig(input) {
+  const issues = [];
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    return { ok: false, issues: [{ path: "", message: "config deve ser um objeto" }] };
+  }
+  const c = input;
+  if (typeof c.product !== "string" || !c.product.trim()) {
+    issues.push({ path: "product", message: "product deve ser uma string n\xE3o vazia" });
+  }
+  if (typeof c.tagline !== "string" || !c.tagline.trim()) {
+    issues.push({ path: "tagline", message: "tagline deve ser uma string n\xE3o vazia" });
+  }
+  if (typeof c.domain !== "string" || !c.domain.trim()) {
+    issues.push({ path: "domain", message: "domain deve ser uma string n\xE3o vazia" });
+  }
+  if (!Array.isArray(c.operations) || !c.operations.every((o) => typeof o === "string" && o.trim())) {
+    issues.push({ path: "operations", message: "operations deve ser um array de strings" });
+  } else if (c.operations.length === 0) {
+    issues.push({ path: "operations", message: "operations n\xE3o pode ser vazio" });
+  }
+  if (!Array.isArray(c.strategies) || !c.strategies.every((s) => typeof s === "string")) {
+    issues.push({ path: "strategies", message: "strategies deve ser um array de strings" });
+  } else {
+    for (const s of c.strategies) {
+      if (!VALID_STRATEGIES.has(s)) {
+        issues.push({ path: "strategies", message: `estrat\xE9gia desconhecida: "${s}". V\xE1lidas: ${STRATEGY_NAMES.join(", ")}` });
+      }
+    }
+    if (c.strategies.length === 0) {
+      issues.push({ path: "strategies", message: "strategies n\xE3o pode ser vazio" });
+    }
+  }
+  if (!Array.isArray(c.providers) || !c.providers.every((p) => p && typeof p === "object" && typeof p.name === "string")) {
+    issues.push({ path: "providers", message: "providers deve ser um array de objetos { name: string }" });
+  } else {
+    c.providers.forEach((p, i) => {
+      const prov = p;
+      if (prov.weight != null && typeof prov.weight !== "number") {
+        issues.push({ path: `providers[${i}].weight`, message: "weight deve ser number" });
+      }
+      if (prov.latency != null && typeof prov.latency !== "number") {
+        issues.push({ path: `providers[${i}].latency`, message: "latency deve ser number" });
+      }
+      if (prov.health != null && (typeof prov.health !== "number" || prov.health < 0 || prov.health > 1)) {
+        issues.push({ path: `providers[${i}].health`, message: "health deve ser number em [0,1]" });
+      }
+    });
+    if (c.providers.length === 0) {
+      issues.push({ path: "providers", message: "providers n\xE3o pode ser vazio" });
+    }
+  }
+  if (c.sdkExamples != null) {
+    if (typeof c.sdkExamples !== "object" || Array.isArray(c.sdkExamples)) {
+      issues.push({ path: "sdkExamples", message: "sdkExamples deve ser um objeto { node?, python?, curl? }" });
+    } else {
+      const allowed = /* @__PURE__ */ new Set(["node", "python", "curl"]);
+      for (const k of Object.keys(c.sdkExamples)) {
+        if (!allowed.has(k)) issues.push({ path: `sdkExamples.${k}`, message: "chave de sdkExamples inv\xE1lida (use node, python ou curl)" });
+        else if (typeof c.sdkExamples[k] !== "string") {
+          issues.push({ path: `sdkExamples.${k}`, message: "sdkExamples value deve ser string" });
+        }
+      }
+    }
+  }
+  if (c.pricing != null) {
+    if (typeof c.pricing !== "object" || Array.isArray(c.pricing)) {
+      issues.push({ path: "pricing", message: "pricing deve ser um objeto de tiers por id" });
+    } else {
+      for (const [tier, v] of Object.entries(c.pricing)) {
+        if (!v || typeof v !== "object") {
+          issues.push({ path: `pricing.${tier}`, message: "tier deve ser um objeto" });
+          continue;
+        }
+        const t = v;
+        if (t.price != null && typeof t.price !== "string") {
+          issues.push({ path: `pricing.${tier}.price`, message: "price deve ser string" });
+        }
+        if (t.requests != null && typeof t.requests !== "string") {
+          issues.push({ path: `pricing.${tier}.requests`, message: "requests deve ser string" });
+        }
+        if (t.providers != null && typeof t.providers !== "number" && t.providers !== "ilimitado") {
+          issues.push({ path: `pricing.${tier}.providers`, message: 'providers deve ser number ou "ilimitado"' });
+        }
+        if (t.features != null && !(Array.isArray(t.features) && t.features.every((f) => typeof f === "string"))) {
+          issues.push({ path: `pricing.${tier}.features`, message: "features deve ser array de strings" });
+        }
+      }
+    }
+  }
+  if (c.cta != null) {
+    if (typeof c.cta !== "object" || Array.isArray(c.cta)) {
+      issues.push({ path: "cta", message: "cta deve ser um objeto { email? }" });
+    } else if (c.cta.email != null && typeof c.cta.email !== "string") {
+      issues.push({ path: "cta.email", message: "cta.email deve ser string" });
+    }
+  }
+  if (issues.length > 0) return { ok: false, issues };
+  return { ok: true, issues: [], config: c };
+}
+var DEFAULT_HERO_CODE = `import { Orchestrator } from '@layerall/sdk';
+
+const client = new Orchestrator({
+  apiKey: process.env.LAYERALL_API_KEY!,
+  baseUrl: 'https://api.seu-allx.com',
+});
+
+const result = await client.operation('create', {
+  payload: { data: {} },
+  strategy: 'most_fast',
+});
+console.log(result.provider, result.status);`;
+function defaultLandingConfig() {
+  return {
+    product: "AllX",
+    tagline: "Um SDK. N provedores. Orquestra\xE7\xE3o plug\xE1vel.",
+    domain: "orquestra\xE7\xE3o",
+    operations: ["create", "send", "status", "cancel"],
+    strategies: ["round_robin", "load_balance", "most_fast", "failover"],
+    providers: [
+      { name: "Provider A", weight: 50, latency: 180, health: 0.96 },
+      { name: "Provider B", weight: 30, latency: 120, health: 0.92 },
+      { name: "Provider C", weight: 20, latency: 90, health: 0.88 }
+    ],
+    sdkExamples: {
+      node: DEFAULT_HERO_CODE,
+      python: `from layerall_sdk import Orchestrator
+client = Orchestrator(api_key=...)
+result = client.operation('create', payload={'data': {}}, strategy='most_fast')`,
+      curl: `curl -X POST 'https://api.seu-allx.com/v1/operation/create' \\
+  -H 'Authorization: Bearer $KEY' \\
+  -d '{"payload":{"data":{}},"strategy":"most_fast"}'`
+    },
+    pricing: {
+      starter: { price: "R$ 0", requests: "10k/m\xEAs", providers: 2 },
+      pro: { price: "R$ 499", requests: "100k/m\xEAs", providers: "ilimitado" },
+      enterprise: { price: "Sob consulta", features: ["SSO", "SLA", "Suporte dedicado"] }
+    },
+    cta: { email: "contato@allx.com" }
+  };
+}
+function escapeHtml(s) {
+  return s.replace(/[&<>]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;" })[c]);
+}
+function renderLanding(config) {
+  const template = readFileSync(TEMPLATE_PATH, "utf8");
+  const heroCode = config.sdkExamples?.node ?? DEFAULT_HERO_CODE;
+  const title = `${config.product} \u2014 ${config.tagline}`;
+  const json = JSON.stringify(config).replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026");
+  return template.replace(/__LAYERALL_TITLE__/g, escapeHtml(title)).replace(/__LAYERALL_TAGLINE__/g, escapeHtml(config.tagline)).replace(/__LAYERALL_PRODUCT__/g, escapeHtml(config.product)).replace(/__LAYERALL_DOMAIN__/g, escapeHtml(config.domain)).replace(/__LAYERALL_HERO_CODE__/g, escapeHtml(heroCode)).replace(/__LAYERALL_CONFIG_JSON__/g, json);
+}
+
+export {
+  buildPolicy,
+  validatePolicy,
+  validateLandingConfig,
+  defaultLandingConfig,
+  renderLanding
+};

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+import {
+  buildPolicy,
+  defaultLandingConfig,
+  renderLanding,
+  validateLandingConfig,
+  validatePolicy
+} from "./chunk-WDABYCHT.js";
+
+// src/cli.ts
+import { Command } from "commander";
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { resolve } from "path";
+var program = new Command();
+program.name("layerall").description("CLI for scaffolding LayerAll policies and provider configs").version(getVersion());
+program.command("init").description("Scaffold a default layerall.policy.json").option("-o, --out <path>", "output file", "layerall.policy.json").option("-p, --providers <ids>", "comma-separated provider ids", "providerA,providerB,providerC").option("-w, --weights <pairs>", "comma-separated id=weight pairs").action((opts) => {
+  const providers = String(opts.providers).split(",").map((s) => s.trim()).filter(Boolean);
+  const weights = parseWeights(opts.weights);
+  const policy = buildPolicy({
+    providers,
+    weights,
+    timeoutMs: 8e3,
+    retries: { max: 1, backoffMs: 300 }
+  });
+  const outPath = resolve(process.cwd(), opts.out);
+  writeFileSync(outPath, JSON.stringify(policy, null, 2) + "\n", "utf8");
+  console.log(`\u2714 Policy written to ${outPath}`);
+});
+program.command("validate <file>").description("Validate a layerall.policy.json file").action((file) => {
+  const path = resolve(process.cwd(), file);
+  if (!existsSync(path)) {
+    console.error(`\u2716 File not found: ${path}`);
+    process.exitCode = 1;
+    return;
+  }
+  const raw = readFileSync(path, "utf8");
+  let json;
+  try {
+    json = JSON.parse(raw);
+  } catch (err) {
+    console.error(`\u2716 Invalid JSON: ${err.message}`);
+    process.exitCode = 1;
+    return;
+  }
+  const issues = validatePolicy(json);
+  if (issues.length === 0) {
+    console.log("\u2714 Policy is valid.");
+  } else {
+    console.error("\u2716 Policy issues:");
+    for (const i of issues) console.error("  -", i);
+    process.exitCode = 1;
+  }
+});
+program.command("init-landing").description("Generate a static marketing landing page from a JSON config").option("-c, --config <path>", "path to landing-config JSON file").option("-o, --out <path>", "output directory", "landing").action((opts) => {
+  let configInput;
+  if (opts.config) {
+    const cfgPath = resolve(process.cwd(), opts.config);
+    if (!existsSync(cfgPath)) {
+      console.error(`\u2716 Config file not found: ${cfgPath}`);
+      process.exitCode = 1;
+      return;
+    }
+    try {
+      configInput = JSON.parse(readFileSync(cfgPath, "utf8"));
+    } catch (err) {
+      console.error(`\u2716 Invalid JSON config: ${err.message}`);
+      process.exitCode = 1;
+      return;
+    }
+  } else {
+    configInput = defaultLandingConfig();
+  }
+  const result = validateLandingConfig(configInput);
+  if (!result.ok || !result.config) {
+    console.error("\u2716 Landing config issues:");
+    for (const i of result.issues) console.error(`  - ${i.path || "(root)"}: ${i.message}`);
+    process.exitCode = 1;
+    return;
+  }
+  const html = renderLanding(result.config);
+  const outDir = resolve(process.cwd(), opts.out);
+  mkdirSync(outDir, { recursive: true });
+  const outPath = resolve(outDir, "index.html");
+  writeFileSync(outPath, html, "utf8");
+  console.log(`\u2714 Landing written to ${outPath}`);
+});
+program.parse(process.argv);
+function parseWeights(input) {
+  if (!input) return void 0;
+  const out = {};
+  for (const pair of String(input).split(",")) {
+    const [id, w] = pair.split("=");
+    if (id) out[id.trim()] = Number(w ?? 1);
+  }
+  return out;
+}
+function getVersion() {
+  try {
+    const pkg = JSON.parse(
+      readFileSync(new URL("../package.json", import.meta.url), "utf8")
+    );
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}

package/dist/index.d.ts

@@ -0,0 +1,77 @@
+import { PolicyDocument } from '@layerall/core';
+
+/** Builds a sensible default policy document for a set of provider ids. */
+declare function buildPolicy(opts: {
+    providers: string[];
+    weights?: Record<string, number>;
+    timeoutMs?: number;
+    retries?: {
+        max: number;
+        backoffMs: number;
+    };
+}): PolicyDocument;
+/** Validates a policy document shape; returns a list of human-readable issues. */
+declare function validatePolicy(policy: unknown): string[];
+
+declare const STRATEGY_NAMES: readonly ["round_robin", "load_balance", "most_fast", "failover"];
+/** Public landing page config — drives every section of the template. */
+interface LandingConfig {
+    /** Product / brand name (e.g. "AllGeo"). */
+    product: string;
+    /** One-line tagline used in `<title>`, meta description and the hero gradient line. */
+    tagline: string;
+    /** Word describing the orchestration domain (e.g. "geocode reverso"). */
+    domain: string;
+    /** Operation names the orchestrator exposes (e.g. ["reverse","batch"]). */
+    operations: string[];
+    /** Strategy names enabled on this product (subset of LayerAll strategies). */
+    strategies: (typeof STRATEGY_NAMES)[number][];
+    /** One entry per integrated provider. */
+    providers: LandingProvider[];
+    /** Source snippets shown in the hero and SDK tabs, keyed by language id. */
+    sdkExamples?: Partial<Record<'node' | 'python' | 'curl', string>>;
+    /** Pricing tiers keyed by tier id (e.g. "starter" / "pro" / "enterprise"). */
+    pricing?: Record<string, LandingPricingTier>;
+    /** Contact call-to-action. */
+    cta?: {
+        /** Contact email used by the primary CTA buttons. */
+        email?: string;
+    };
+}
+interface LandingProvider {
+    /** Display name (e.g. "Google Maps"). */
+    name: string;
+    /** Traffic weight used by load_balance (defaults to 1). */
+    weight?: number;
+    /** Base latency in ms shown in the provider card. */
+    latency?: number;
+    /** Health score in [0,1] shown in the provider card. */
+    health?: number;
+}
+interface LandingPricingTier {
+    /** Display price (e.g. "R$ 0", "Sob consulta"). */
+    price?: string;
+    /** Volume legend (e.g. "10k/mês"). */
+    requests?: string;
+    /** Count of providers allowed, or "ilimitado". */
+    providers?: number | 'ilimitado';
+    /** Extra bullet features. */
+    features?: string[];
+}
+interface LandingValidationIssue {
+    path: string;
+    message: string;
+}
+interface LandingValidationResult {
+    ok: boolean;
+    issues: LandingValidationIssue[];
+    config?: LandingConfig;
+}
+/** Validates a raw config object against the LandingConfig shape. */
+declare function validateLandingConfig(input: unknown): LandingValidationResult;
+/** Default config used when --config is not provided: a brandable agnostic template. */
+declare function defaultLandingConfig(): LandingConfig;
+/** Renders the full single-file landing HTML for the supplied config. */
+declare function renderLanding(config: LandingConfig): string;
+
+export { type LandingConfig, type LandingPricingTier, type LandingProvider, type LandingValidationIssue, type LandingValidationResult, buildPolicy, defaultLandingConfig, renderLanding, validateLandingConfig, validatePolicy };

package/dist/index.js

@@ -0,0 +1,14 @@
+import {
+  buildPolicy,
+  defaultLandingConfig,
+  renderLanding,
+  validateLandingConfig,
+  validatePolicy
+} from "./chunk-WDABYCHT.js";
+export {
+  buildPolicy,
+  defaultLandingConfig,
+  renderLanding,
+  validateLandingConfig,
+  validatePolicy
+};