@johpaz/hive-sdk 0.1.6 → 0.3.0

package/packages/core/src/tools/ToolRegistry.test.ts

@@ -1,98 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { ToolRegistry, defineTool } from "./ToolRegistry.ts";
-import { ToolExecutor } from "./ToolExecutor.ts";
-
-describe("defineTool", () => {
-	it("creates a tool definition", () => {
-		const tool = defineTool({
-			name: "hello",
-			description: "Say hello",
-			execute: async (args: { name?: string }) => ({ greeting: `Hello, ${args.name ?? "world"}!` }),
-		});
-		expect(tool.name).toBe("hello");
-		expect(tool.description).toBe("Say hello");
-	});
-});
-
-describe("ToolRegistry", () => {
-	it("register, get, has", () => {
-		const reg = new ToolRegistry();
-		const tool = defineTool({
-			name: "test",
-			description: "a test tool",
-			execute: async () => ({ ok: true }),
-		});
-		reg.register(tool);
-		expect(reg.has("test")).toBe(true);
-		expect(reg.get("test")).toBe(tool);
-		expect(reg.get("nope")).toBeUndefined();
-	});
-
-	it("throws on duplicate registration", () => {
-		const reg = new ToolRegistry();
-		reg.register(defineTool({ name: "dup", description: "", execute: async () => ({}) }));
-		expect(() =>
-			reg.register(defineTool({ name: "dup", description: "", execute: async () => ({}) }))
-		).toThrow("already registered");
-	});
-
-	it("lists and categorizes", () => {
-		const reg = new ToolRegistry();
-		reg.register(defineTool({ name: "a", description: "", category: "web", execute: async () => ({}) }));
-		reg.register(defineTool({ name: "b", description: "", category: "fs", execute: async () => ({}) }));
-		reg.register(defineTool({ name: "c", description: "", category: "web", execute: async () => ({}) }));
-		expect(reg.size()).toBe(3);
-		expect(reg.list()).toHaveLength(3);
-		expect(reg.getByCategory("web")).toHaveLength(2);
-		expect(reg.getNames()).toEqual(["a", "b", "c"]);
-	});
-
-	it("merge and clear", () => {
-		const a = new ToolRegistry();
-		const b = new ToolRegistry();
-		a.register(defineTool({ name: "x", description: "", execute: async () => ({}) }));
-		b.register(defineTool({ name: "y", description: "", execute: async () => ({}) }));
-		a.merge(b);
-		expect(a.size()).toBe(2);
-		a.clear();
-		expect(a.size()).toBe(0);
-	});
-});
-
-describe("ToolExecutor", () => {
-	it("executes a registered tool", async () => {
-		const reg = new ToolRegistry();
-		reg.register(
-			defineTool({
-				name: "echo",
-				description: "echo args",
-				execute: async (args) => args,
-			})
-		);
-		const exec = new ToolExecutor(reg);
-		const result = await exec.execute("echo", { msg: "hi" });
-		expect(result.toolName).toBe("echo");
-		expect(result.result).toEqual({ msg: "hi" });
-		expect(result.error).toBeUndefined();
-		expect(result.durationMs).toBeGreaterThanOrEqual(0);
-	});
-
-	it("returns error for unknown tool", async () => {
-		const exec = new ToolExecutor(new ToolRegistry());
-		const result = await exec.execute("ghost", {});
-		expect(result.error).toBeString();
-		expect(result.error).toContain("not found");
-	});
-
-	it("executes batch", async () => {
-		const reg = new ToolRegistry();
-		reg.register(defineTool({ name: "t1", description: "", execute: async () => 1 }));
-		reg.register(defineTool({ name: "t2", description: "", execute: async () => 2 }));
-		const exec = new ToolExecutor(reg);
-		const results = await exec.executeBatch([{ name: "t1", args: {} }, { name: "t2", args: {} }, { name: "nope", args: {} }]);
-		expect(results).toHaveLength(3);
-		expect(results[0].result).toBe(1);
-		expect(results[1].result).toBe(2);
-		expect(results[2].error).toBeString();
-	});
-});

package/packages/core/src/tools/api/api-request.test.ts

@@ -1,164 +0,0 @@
-/**
- * `api_request` cambió de contrato en 0.1.5.
- *
- * El tool anterior (`tools/web/api-request.ts`) tenía helpers de autenticación
- * (`auth: { type: "bearer" | "basic" | "api_key" }`), aceptaba `body` como
- * objeto y devolvía `{ ok, status, data }`. El de hive es más chato: la
- * autenticación va como un header más, `body` es string, y la respuesta expone
- * `body` + `contentType` en vez de `data`.
- */
-
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import { apiRequestTool } from "./api-request.ts";
-
-describe("apiRequestTool", () => {
-  let originalFetch: typeof fetch;
-
-  beforeEach(() => {
-    originalFetch = globalThis.fetch;
-  });
-
-  afterEach(() => {
-    globalThis.fetch = originalFetch;
-  });
-
-  function stubFetch(handler: (url: string, init: RequestInit) => Response) {
-    globalThis.fetch = Object.assign(
-      async (url: any, init?: any) => handler(url.toString(), init ?? {}),
-      { preconnect: async () => undefined }
-    ) as typeof fetch;
-  }
-
-  function jsonResponse(body: unknown, init: ResponseInit = {}) {
-    return new Response(JSON.stringify(body), {
-      status: init.status ?? 200,
-      statusText: init.statusText ?? "OK",
-      headers: { "content-type": "application/json" },
-    });
-  }
-
-  it("ejecuta un GET simple y parsea el JSON", async () => {
-    let capturedUrl = "";
-    let capturedInit: RequestInit = {};
-    stubFetch((url, init) => {
-      capturedUrl = url;
-      capturedInit = init;
-      return jsonResponse({ hello: "world" });
-    });
-
-    const result = await apiRequestTool.execute({
-      method: "GET",
-      url: "https://api.example.com/data",
-    }) as any;
-
-    expect(capturedUrl).toBe("https://api.example.com/data");
-    expect(capturedInit.method).toBe("GET");
-    expect(result.ok).toBe(true);
-    expect(result.status).toBe(200);
-    expect(result.body).toEqual({ hello: "world" });
-  });
-
-  it("manda POST con el body tal cual y los headers dados", async () => {
-    let capturedInit: RequestInit = {};
-    stubFetch((_url, init) => {
-      capturedInit = init;
-      return jsonResponse({ id: 1 }, { status: 201, statusText: "Created" });
-    });
-
-    const result = await apiRequestTool.execute({
-      method: "POST",
-      url: "https://api.example.com/items",
-      body: JSON.stringify({ name: "test" }),
-      headers: { "Content-Type": "application/json", Authorization: "Bearer tok" },
-    }) as any;
-
-    expect(capturedInit.method).toBe("POST");
-    expect(capturedInit.body).toBe('{"name":"test"}');
-    expect((capturedInit.headers as Record<string, string>).Authorization).toBe("Bearer tok");
-    expect(result.status).toBe(201);
-    expect(result.body).toEqual({ id: 1 });
-  });
-
-  it("codifica query_params en la URL", async () => {
-    let capturedUrl = "";
-    stubFetch((url) => {
-      capturedUrl = url;
-      return jsonResponse({});
-    });
-
-    await apiRequestTool.execute({
-      method: "GET",
-      url: "https://api.example.com/search",
-      query_params: { q: "hola mundo", limit: "10" },
-    });
-
-    expect(capturedUrl).toContain("q=hola+mundo");
-    expect(capturedUrl).toContain("limit=10");
-  });
-
-  it("devuelve texto plano sin intentar parsearlo", async () => {
-    stubFetch(() => new Response("hello world", {
-      status: 200,
-      statusText: "OK",
-      headers: { "content-type": "text/plain" },
-    }));
-
-    const result = await apiRequestTool.execute({
-      method: "GET",
-      url: "https://api.example.com/text",
-    }) as any;
-
-    expect(result.ok).toBe(true);
-    expect(result.body).toBe("hello world");
-    expect(result.contentType).toContain("text/plain");
-  });
-
-  it("marca ok:false en un HTTP no exitoso sin lanzar", async () => {
-    stubFetch(() => jsonResponse({ error: "not found" }, { status: 404, statusText: "Not Found" }));
-
-    const result = await apiRequestTool.execute({
-      method: "GET",
-      url: "https://api.example.com/missing",
-    }) as any;
-
-    expect(result.ok).toBe(false);
-    expect(result.status).toBe(404);
-    expect(result.statusText).toBe("Not Found");
-  });
-
-  it("rechaza un método no permitido antes de tocar la red", async () => {
-    let called = false;
-    stubFetch(() => { called = true; return jsonResponse({}); });
-
-    const result = await apiRequestTool.execute({
-      method: "TRACE",
-      url: "https://api.example.com/data",
-    }) as any;
-
-    expect(called).toBe(false);
-    expect(result.ok).toBe(false);
-    expect(result.error).toContain("Invalid HTTP method");
-  });
-
-  it("exige url", async () => {
-    const result = await apiRequestTool.execute({ method: "GET" }) as any;
-
-    expect(result.ok).toBe(false);
-    expect(result.error).toContain("url");
-  });
-
-  it("devuelve el error de red como resultado, no como excepción", async () => {
-    globalThis.fetch = Object.assign(
-      async () => { throw new Error("ECONNREFUSED"); },
-      { preconnect: async () => undefined }
-    ) as typeof fetch;
-
-    const result = await apiRequestTool.execute({
-      method: "GET",
-      url: "https://api.example.com/down",
-    }) as any;
-
-    expect(result.ok).toBe(false);
-    expect(result.error).toContain("ECONNREFUSED");
-  });
-});

package/packages/core/src/tools/web/browser-service.test.ts

@@ -1,83 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import {
-  AgentBrowserView,
-  BrowserService,
-  initializeBrowserService,
-  getBrowserService,
-  waitForSelector,
-  waitForCondition,
-} from "./browser-service.ts";
-import type { Config } from "../../config/loader.ts";
-
-describe("AgentBrowserView", () => {
-  it("has the expected API surface", () => {
-    const view = new AgentBrowserView("test-session");
-    expect(view.url).toBe("");
-    expect(typeof view.navigate).toBe("function");
-    expect(typeof view.evaluate).toBe("function");
-    expect(typeof view.click).toBe("function");
-    expect(typeof view.type).toBe("function");
-    expect(typeof view.typeIn).toBe("function");
-    expect(typeof view.fill).toBe("function");
-    expect(typeof view.press).toBe("function");
-    expect(typeof view.scroll).toBe("function");
-    expect(typeof view.scrollTo).toBe("function");
-    expect(typeof view.back).toBe("function");
-    expect(typeof view.forward).toBe("function");
-    expect(typeof view.reload).toBe("function");
-    expect(typeof view.resize).toBe("function");
-    expect(typeof view.screenshot).toBe("function");
-    expect(typeof view.snapshot).toBe("function");
-    expect(typeof view.cdp).toBe("function");
-    expect(typeof view.close).toBe("function");
-  });
-});
-
-describe("BrowserService singleton", () => {
-  it("initializes and returns the same instance", () => {
-    const config = { tools: { browser: { enabled: true, sessionName: "test" } } } as Config;
-    const service = initializeBrowserService(config);
-    expect(service).toBeInstanceOf(BrowserService);
-    expect(getBrowserService()).toBe(service);
-  });
-
-  it("exposes expected service methods", () => {
-    const config = { tools: { browser: { enabled: true, sessionName: "test" } } } as Config;
-    const service = BrowserService.getInstance(config);
-    expect(typeof service.start).toBe("function");
-    expect(typeof service.getView).toBe("function");
-    expect(typeof service.isAvailable).toBe("function");
-    expect(typeof service.stop).toBe("function");
-  });
-});
-
-describe("wait helpers", () => {
-  it("waitForSelector resolves when element appears", async () => {
-    let found = false;
-    const view = {
-      evaluate: async (script: string) => {
-        if (script.includes("document.querySelector")) {
-          found = true;
-          return true;
-        }
-        return false;
-      },
-    } as unknown as AgentBrowserView;
-
-    await waitForSelector(view, "#test", 1000);
-    expect(found).toBe(true);
-  });
-
-  it("waitForCondition resolves when expression is truthy", async () => {
-    let calls = 0;
-    const view = {
-      evaluate: async () => {
-        calls++;
-        return calls >= 2;
-      },
-    } as unknown as AgentBrowserView;
-
-    await waitForCondition(view, "window.ready", 1000);
-    expect(calls).toBeGreaterThanOrEqual(2);
-  });
-});

package/packages/core/src/workers/workers.test.ts

@@ -1,41 +0,0 @@
-process.env.HIVE_DB_PATH = ":memory:";
-
-import { describe, expect, it } from "bun:test";
-import { createWorker, WorkerPool } from "./index.ts";
-
-describe("createWorker", () => {
-  it("creates a worker instance with config", () => {
-    const worker = createWorker({
-      name: "test-worker",
-      systemPrompt: "You are a test worker.",
-    });
-
-    expect(worker.name).toBe("test-worker");
-    expect(worker.id).toContain("test-worker-");
-    worker.terminate();
-  });
-
-  it("WorkerPool creates and manages workers", () => {
-    const pool = new WorkerPool({ maxWorkers: 2 });
-    expect(pool.stats.total).toBe(0);
-    expect(pool.stats.idle).toBe(0);
-    expect(pool.stats.busy).toBe(0);
-    pool.shutdown();
-  });
-
-  it("WorkerPool executes tasks with limited concurrency", async () => {
-    const pool = new WorkerPool({
-      maxWorkers: 2,
-      workerConfig: { name: "pool-test" },
-    });
-
-    const tasks = Array.from({ length: 4 }, (_, i) => ({
-      id: `task-${i}`,
-      message: `Test message ${i}`,
-    }));
-
-    // Since we don't have a real LLM in tests, we just verify the pool structure
-    expect(tasks).toHaveLength(4);
-    pool.shutdown();
-  });
-});

package/scripts/bump-version.ts

@@ -1,248 +0,0 @@
-#!/usr/bin/env bun
-
-/**
- * Bump de versión del SDK.
- *
- * Portado de `hive/scripts/bump-version.ts`, adaptado a este repo: acá el
- * artefacto publicado es **sólo el paquete raíz** (`@johpaz/hive-sdk`);
- * `packages/core` y `packages/cli` son workspaces internos que se versionan en
- * paralelo por consistencia, no se publican.
- *
- * El push del tag `vX.Y.Z` es lo que dispara `.github/workflows/publish.yml`.
- */
-
-const args = process.argv.slice(2);
-const dryRun = args.includes("--dry-run");
-const shouldPush = args.includes("--push");
-const npmTagArg = args.find((a) => a.startsWith("--npm-tag="));
-const npmTag = npmTagArg ? npmTagArg.split("=")[1] : "latest";
-const positional = args.filter((a) => !a.startsWith("--"));
-const bumpType = positional[0] as "patch" | "minor" | "major" | string;
-const explicitVersion = positional[0]?.match(/^\d+\.\d+\.\d+(-[\w.]+)?$/) ? positional[0] : null;
-
-if (!bumpType || (!["patch", "minor", "major"].includes(bumpType) && !explicitVersion)) {
-  console.log("Usage:");
-  console.log("  bun scripts/bump-version.ts patch|minor|major [--push] [--dry-run] [--npm-tag=<tag>]");
-  console.log("  bun scripts/bump-version.ts 0.1.5 [--push] [--dry-run] [--npm-tag=<tag>]");
-  console.log("");
-  console.log("  (sin flags)    Solo actualiza archivos locales (package.json, README, CHANGELOG).");
-  console.log("                 No toca git. Revisá el diff vos mismo.");
-  console.log("  --dry-run      Muestra qué cambiaría, sin escribir nada.");
-  console.log("  --push         Además de bumpear: commitea, crea el tag vX.Y.Z y pushea.");
-  console.log("                 El tag dispara publish.yml, que publica en npm.");
-  console.log("  --npm-tag=X    dist-tag de npm (default: latest). Usá `next` o `beta` para");
-  console.log("                 una preview que no se instale con `bun add @johpaz/hive-sdk`.");
-  console.log("");
-  console.log("Ejemplos:");
-  console.log("  bun scripts/bump-version.ts 0.1.5                    # solo archivos");
-  console.log("  bun scripts/bump-version.ts 0.1.5 --push             # release a latest");
-  console.log("  bun scripts/bump-version.ts 0.2.0-rc.1 --push --npm-tag=next");
-  process.exit(1);
-}
-
-function bumpVersion(current: string, type: "patch" | "minor" | "major"): string {
-  const [major, minor, patch] = current.split("-")[0].split(".").map(Number);
-  return type === "major"
-    ? `${major + 1}.0.0`
-    : type === "minor"
-      ? `${major}.${minor + 1}.0`
-      : `${major}.${minor}.${patch + 1}`;
-}
-
-async function confirm(message: string): Promise<boolean> {
-  const readline = await import("node:readline/promises");
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  const answer = await rl.question(`${message} (escribe "si" para confirmar): `);
-  rl.close();
-  return answer.trim().toLowerCase() === "si";
-}
-
-/** El raíz es el que se publica; los workspaces van en paralelo por consistencia. */
-const packageFiles = [
-  "package.json",
-  "packages/core/package.json",
-  "packages/cli/package.json",
-];
-
-/** Menciones de versión en prosa que no salen de ningún package.json. */
-function textReplacements(newVersion: string) {
-  return [
-    {
-      path: "README.md",
-      pattern: /\*Hive SDK v[\d.]+(?:-[\w.]+)? — MIT\*/g,
-      replacement: `*Hive SDK v${newVersion} — MIT*`,
-    },
-  ];
-}
-
-async function main() {
-  const rootPkg = JSON.parse(await Bun.file("package.json").text());
-  const currentVersion: string = rootPkg.version;
-  const newVersion = explicitVersion || bumpVersion(currentVersion, bumpType as "patch" | "minor" | "major");
-
-  console.log(`\n📦 Bumping version: ${currentVersion} → ${newVersion}`);
-  console.log(`   npm dist-tag: ${npmTag}\n`);
-
-  if (newVersion === currentVersion && !explicitVersion) {
-    console.log("⚠️  La versión nueva es igual a la actual. Abortando.");
-    process.exit(1);
-  }
-
-  // npm rechaza republicar una versión existente: mejor enterarse acá que en CI.
-  try {
-    const published = await fetch(`https://registry.npmjs.org/${rootPkg.name}`)
-      .then((r) => (r.ok ? r.json() : null)) as { versions?: Record<string, unknown> } | null;
-    if (published?.versions?.[newVersion]) {
-      console.log(`⚠️  ${rootPkg.name}@${newVersion} YA está publicada en npm.`);
-      console.log(`   Un publish con esta versión falla con 403. Elegí otra.\n`);
-      if (!dryRun) process.exit(1);
-    }
-  } catch {
-    console.log("   (no se pudo consultar npm — sigo igual)\n");
-  }
-
-  if (dryRun) {
-    console.log("🔎 Dry run — nada se escribe.\n");
-    for (const filePath of packageFiles) {
-      try {
-        const json = JSON.parse(await Bun.file(filePath).text());
-        console.log(`  ${filePath}: ${json.version} → ${newVersion}`);
-      } catch (e) {
-        console.log(`  ⚠️  ${filePath}: ${(e as Error).message}`);
-      }
-    }
-    for (const file of textReplacements(newVersion)) {
-      try {
-        const content = await Bun.file(file.path).text();
-        const matches = content.match(file.pattern);
-        console.log(`  ${file.path}: ${matches ? `${matches.length} coincidencia(s)` : "sin coincidencias (revisar patrón)"}`);
-      } catch (e) {
-        console.log(`  ⚠️  ${file.path}: ${(e as Error).message}`);
-      }
-    }
-    if (shouldPush) {
-      console.log(`\n  Luego: git add -A && git commit -m "chore: release v${newVersion}"`);
-      console.log(`         git tag v${newVersion} && git push origin main && git push origin v${newVersion}`);
-      console.log(`         → publish.yml publica con dist-tag "${npmTag}"`);
-    } else {
-      console.log(`\n  Sin --push: no se toca git.`);
-    }
-    return;
-  }
-
-  for (const filePath of packageFiles) {
-    try {
-      const json = JSON.parse(await Bun.file(filePath).text());
-      const oldVersion = json.version;
-      json.version = newVersion;
-      await Bun.write(filePath, JSON.stringify(json, null, 2) + "\n");
-      console.log(`✅ ${filePath}`);
-      console.log(`   ${json.name}: ${oldVersion} → ${newVersion}`);
-    } catch (e) {
-      console.log(`⚠️  ${filePath}: ${(e as Error).message}`);
-    }
-  }
-
-  for (const file of textReplacements(newVersion)) {
-    try {
-      const content = await Bun.file(file.path).text();
-      const matched = file.pattern.test(content);
-      file.pattern.lastIndex = 0; // test() con /g deja estado — resetear
-      const newContent = content.replace(file.pattern, file.replacement);
-
-      if (!matched) {
-        console.log(`⚠️  ${file.path}: el patrón no matcheó nada — revisar manualmente`);
-      } else if (newContent !== content) {
-        await Bun.write(file.path, newContent);
-        console.log(`✅ ${file.path}`);
-      } else {
-        console.log(`✅ ${file.path} (ya estaba en ${newVersion})`);
-      }
-    } catch (e) {
-      console.log(`⚠️  ${file.path}: ${(e as Error).message}`);
-    }
-  }
-
-  // El CHANGELOG lo escribe una persona; acá sólo avisamos si falta la entrada.
-  try {
-    const changelog = await Bun.file("CHANGELOG.md").text();
-    if (!changelog.includes(`## ${newVersion}`)) {
-      console.log(`\n⚠️  CHANGELOG.md no tiene una sección "## ${newVersion}". Agregala antes de publicar.`);
-    }
-  } catch {
-    console.log("\n⚠️  No hay CHANGELOG.md.");
-  }
-
-  const { execSync } = await import("child_process");
-  const run = (cmd: string) => execSync(cmd, { stdio: "inherit" });
-
-  console.log(`\n✨ Archivos actualizados. Versión: ${newVersion}\n`);
-
-  if (!shouldPush) {
-    console.log("Sin --push: no se tocó git. Revisá `git diff`, y cuando estés conforme:");
-    console.log(`  bun scripts/bump-version.ts ${explicitVersion || bumpType} --push${npmTag !== "latest" ? ` --npm-tag=${npmTag}` : ""}\n`);
-    return;
-  }
-
-  // ── Git: commit, tag y push — con confirmación antes de publicar ──────────
-  console.log("Antes de publicar corro typecheck y tests.\n");
-  try {
-    run("bun run typecheck");
-    run("bun test");
-  } catch {
-    console.log("\n❌ typecheck o tests fallaron. No se publica.");
-    process.exit(1);
-  }
-
-  console.log("\nEsto es lo que se va a commitear (git add -A):\n");
-  run("git status --short");
-
-  const tagExists = (() => {
-    try {
-      execSync(`git rev-parse v${newVersion}`, { stdio: "ignore" });
-      return true;
-    } catch {
-      return false;
-    }
-  })();
-
-  if (tagExists) {
-    console.log(`\n⚠️  El tag v${newVersion} ya existe localmente. Suele indicar que esta`);
-    console.log(`   versión ya se publicó. Abortando — si es intencional, borralo primero`);
-    console.log(`   (git tag -d v${newVersion}) y volvé a correr con --push.`);
-    process.exit(1);
-  }
-
-  const branch = execSync("git branch --show-current").toString().trim();
-
-  console.log(`\nEsto va a: commitear todo lo de arriba como "chore: release v${newVersion}",`);
-  console.log(`crear el tag v${newVersion}, y pushear ${branch} + el tag a origin.`);
-  console.log(`El push del tag dispara publish.yml, que publica en npm con dist-tag "${npmTag}".\n`);
-
-  const ok = await confirm(`¿Publicar v${newVersion} como "${npmTag}"?`);
-  if (!ok) {
-    console.log("Cancelado. No se tocó git.");
-    return;
-  }
-
-  console.log("🔧 Committing changes...");
-  run("git add -A");
-  try {
-    run(`git commit -m "chore: release v${newVersion}"`);
-  } catch {
-    console.log("   (nothing to commit, skipping)");
-  }
-
-  console.log(`🏷️  Creating tag v${newVersion}...`);
-  // El dist-tag viaja en el mensaje del tag: publish.yml lo lee de ahí.
-  run(`git tag -a v${newVersion} -m "release v${newVersion} [npm-tag:${npmTag}]"`);
-
-  console.log("🚀 Pushing commit and tag...");
-  run(`git push origin ${branch}`);
-  run(`git push origin v${newVersion}`);
-
-  console.log(`\n🎉 Released v${newVersion} (dist-tag: ${npmTag})\n`);
-  console.log(`Verificá en unos minutos:  npm view ${rootPkg.name} dist-tags\n`);
-}
-
-main().catch(console.error);