@johpaz/hive-sdk 0.1.4 → 0.1.6

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

@@ -0,0 +1,164 @@
+/**
+ * `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/api/api-request.ts

@@ -0,0 +1,174 @@
+/**
+ * api_request - Make HTTP requests to REST APIs (curl-like)
+ *
+ * Supports: GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS
+ * Features: custom headers, JSON/form body, query params, timeout
+ *
+ * @category api
+ * @seedId api_request
+ * @spanish llamar api, petición http, curl, post a api, put api, delete api
+ */
+
+import type { Tool } from "../types.ts";
+import { logger } from "../../utils/logger.ts";
+
+const log = logger.child("api-request");
+
+const ALLOWED_METHODS = ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"];
+
+export const apiRequestTool: Tool = {
+  name: "api_request",
+  description:
+    "Make an HTTP request to a REST API endpoint. Supports GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS with custom headers, body, and query parameters. " +
+    "Spanish: llamar api, petición http, curl, post a api, put api, delete api, consumir servicio rest",
+  parameters: {
+    type: "object",
+    properties: {
+      method: {
+        type: "string",
+        description: "HTTP method: GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS",
+        enum: ALLOWED_METHODS,
+      },
+      url: {
+        type: "string",
+        description: "Full URL of the API endpoint (including query string, or use query_params)",
+      },
+      headers: {
+        type: "object",
+        description: "Optional HTTP headers as key-value pairs. Example: {\"Content-Type\": \"application/json\", \"Authorization\": \"Bearer token\"}",
+        additionalProperties: { type: "string" },
+      },
+      body: {
+        type: "string",
+        description: "Optional request body as a string. For JSON APIs, pass a JSON string. For form data, pass URL-encoded string.",
+      },
+      query_params: {
+        type: "object",
+        description: "Optional query parameters as key-value pairs. Will be URL-encoded and appended to the URL.",
+        additionalProperties: { type: "string" },
+      },
+      timeout_ms: {
+        type: "number",
+        description: "Request timeout in milliseconds. Default: 30000 (30s). Max: 120000 (2 min).",
+        minimum: 1000,
+        maximum: 120000,
+      },
+    },
+    required: ["method", "url"],
+  },
+  execute: async (params: Record<string, unknown>) => {
+    const method = (params.method as string)?.toUpperCase().trim() || "GET";
+    let url = params.url as string;
+    const headers = (params.headers as Record<string, string>) || {};
+    const body = params.body as string | undefined;
+    const queryParams = (params.query_params as Record<string, string>) || {};
+    const timeoutMs = (params.timeout_ms as number) || 30000;
+
+    if (!ALLOWED_METHODS.includes(method)) {
+      return {
+        ok: false,
+        error: `Invalid HTTP method: ${method}. Allowed: ${ALLOWED_METHODS.join(", ")}`,
+      };
+    }
+
+    if (!url || typeof url !== "string") {
+      return {
+        ok: false,
+        error: "Missing required parameter: url",
+      };
+    }
+
+    // Append query params to URL
+    if (Object.keys(queryParams).length > 0) {
+      const urlObj = new URL(url);
+      for (const [key, value] of Object.entries(queryParams)) {
+        urlObj.searchParams.append(key, value);
+      }
+      url = urlObj.toString();
+    }
+
+    log.info(`[api_request] ${method} ${url}`);
+
+    const fetchOptions: RequestInit = {
+      method,
+      headers: {
+        "User-Agent": "HiveAgent/1.0",
+        ...headers,
+      },
+      // @ts-ignore — Bun supports timeout
+      timeout: timeoutMs,
+    };
+
+    if (body !== undefined && body !== null && body !== "") {
+      // Auto-set Content-Type to application/json if body looks like JSON
+      if (
+        !headers["Content-Type"] &&
+        !headers["content-type"] &&
+        typeof body === "string" &&
+        (body.trim().startsWith("{") || body.trim().startsWith("["))
+      ) {
+        (fetchOptions.headers as Record<string, string>)["Content-Type"] = "application/json";
+      }
+      fetchOptions.body = body;
+    }
+
+    try {
+      const response = await fetch(url, fetchOptions);
+
+      // For HEAD requests, don't read body
+      if (method === "HEAD") {
+        const responseHeaders: Record<string, string> = {};
+        response.headers.forEach((value, key) => {
+          responseHeaders[key] = value;
+        });
+        return {
+          ok: response.ok,
+          status: response.status,
+          statusText: response.statusText,
+          headers: responseHeaders,
+          url: response.url,
+        };
+      }
+
+      const contentType = response.headers.get("content-type") || "";
+      let responseBody: string | object;
+      const rawText = await response.text();
+
+      if (contentType.includes("application/json")) {
+        try {
+          responseBody = JSON.parse(rawText);
+        } catch {
+          responseBody = rawText;
+        }
+      } else {
+        responseBody = rawText;
+      }
+
+      const responseHeaders: Record<string, string> = {};
+      response.headers.forEach((value, key) => {
+        responseHeaders[key] = value;
+      });
+
+      log.info(`[api_request] ${method} ${url} → ${response.status} ${response.statusText}`);
+
+      return {
+        ok: response.ok,
+        status: response.status,
+        statusText: response.statusText,
+        headers: responseHeaders,
+        body: responseBody,
+        contentType,
+        url: response.url,
+      };
+    } catch (error) {
+      const msg = (error as Error).message;
+      log.error(`[api_request] ${method} ${url} failed: ${msg}`);
+      return {
+        ok: false,
+        error: `HTTP request failed: ${msg}`,
+        url,
+        method,
+      };
+    }
+  },
+};

package/packages/core/src/tools/api/index.ts

@@ -0,0 +1,16 @@
+/**
+ * API Tools - HTTP client for REST APIs (curl-like)
+ *
+ * Makes requests to external APIs with full control over method, headers, body.
+ */
+
+import type { Tool } from "../types.ts";
+import { apiRequestTool } from "./api-request.ts";
+
+export function createTools(): Tool[] {
+  return [
+    apiRequestTool,
+  ];
+}
+
+export { apiRequestTool } from "./api-request.ts";

package/packages/core/src/tools/cli/index.ts

@@ -30,6 +30,10 @@ const BLOCKED_PATTERNS: Array<{ pattern: RegExp; reason: string }> = [
 
 export const cliExecTool: Tool = {
   name: "cli_exec",
+  // Long-running commands need a generous runtime ceiling (the tool allows
+  // its own per-call `timeout` up to 300s, so the harness timeout must be
+  // above that to avoid the worker killing a still-running command).
+  timeoutMs: 330000,
   description: "Execute shell/bash commands in the agent workspace. NOTE: do NOT use for scheduling tasks, use cron.create instead. Spanish: ejecutar comando, terminal, bash, script, consola",
   parameters: {
     type: "object",