@telorun/http-client 0.1.1

package/LICENSE

@@ -0,0 +1,17 @@
+# SUSTAINABLE USE LICENSE (Fair-code)
+
+Copyright (c) 2026 DiglyAI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to use, copy, modify, and distribute the Software for any purpose—including commercial purposes—subject to the following conditions:
+
+1. ANTI-COMPETITION RESTRICTION: The Software may not be provided to third parties as a managed service, commercial SaaS (Software-as-a-Service), PaaS (Platform-as-a-Service), BaaS (Backend-as-a-Service), or similar offering where the primary value provided to the user is the functionality of the Software itself, without a separate commercial license from the copyright holder.
+
+2. PERMITTED COMMERCIAL USE: You are free to use the Software to build, host, and monetize your own commercial applications, products, and services, provided such use does not violate Clause 1.
+
+3. ATTRIBUTION: This copyright notice and license must be included in all copies or substantial portions of the Software.
+
+4. CONTRIBUTIONS: Contributions to the Software are welcome and encouraged. By contributing, you agree that your contributions may be incorporated into the Software and distributed under this license.
+
+5. DISCLAIMER: 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.
+
+For commercial licensing, managed hosting exemptions, or enterprise inquiries, please contact DiglyAI.

package/dist/http-client-controller.d.ts

@@ -0,0 +1,25 @@
+import type { ResourceContext, ResourceInstance } from "@telorun/sdk";
+interface HttpClientManifest {
+    baseUrl?: string;
+    headers?: Record<string, string>;
+    timeout?: number;
+    followRedirects?: boolean;
+}
+declare class HttpClientResource implements ResourceInstance {
+    private readonly manifest;
+    readonly metadata: {
+        name: string;
+        module: string;
+        [key: string]: any;
+    };
+    constructor(manifest: any);
+    snapshot(): {
+        baseUrl: any;
+        headers: any;
+        timeout: any;
+        followRedirects: any;
+    };
+}
+export declare function register(): void;
+export declare function create(resource: HttpClientManifest, _ctx: ResourceContext): Promise<HttpClientResource>;
+export {};

package/dist/http-client-controller.js

@@ -0,0 +1,20 @@
+class HttpClientResource {
+    manifest;
+    metadata;
+    constructor(manifest) {
+        this.manifest = manifest;
+        this.metadata = manifest.metadata ?? {};
+    }
+    snapshot() {
+        return {
+            baseUrl: this.manifest.baseUrl ?? "",
+            headers: this.manifest.headers ?? {},
+            timeout: this.manifest.timeout ?? 10000,
+            followRedirects: this.manifest.followRedirects ?? true,
+        };
+    }
+}
+export function register() { }
+export async function create(resource, _ctx) {
+    return new HttpClientResource(resource);
+}

package/dist/http-request-controller.d.ts

@@ -0,0 +1,26 @@
+import type { ResourceContext, ResourceInstance } from "@telorun/sdk";
+interface TeloResponse {
+    status: number;
+    headers: Record<string, string>;
+    body: unknown;
+}
+interface HttpRequestManifest {
+    client?: string;
+    url: string;
+    method?: string;
+    query?: Record<string, string>;
+    headers?: Record<string, string>;
+    body?: string | Record<string, unknown>;
+    timeout?: number;
+    throwOnHttpError?: boolean;
+    retries?: number;
+}
+declare class HttpRequestResource implements ResourceInstance {
+    private readonly manifest;
+    private readonly ctx;
+    constructor(manifest: HttpRequestManifest, ctx: ResourceContext);
+    invoke(input: any): Promise<TeloResponse>;
+}
+export declare function register(): void;
+export declare function create(resource: HttpRequestManifest, ctx: ResourceContext): Promise<HttpRequestResource>;
+export {};

package/dist/http-request-controller.js

@@ -0,0 +1,179 @@
+const MAX_REDIRECTS = 5;
+const DEFAULT_TIMEOUT = 10000;
+function createNetworkError(code, message, url) {
+    const payload = {
+        error: "NetworkError",
+        code,
+        message,
+        details: { url },
+    };
+    const err = new Error(message);
+    err.networkError = payload;
+    err.code = code;
+    Object.assign(err, payload);
+    return err;
+}
+function mapNetworkError(err, url) {
+    const e = err;
+    if (e.name === "AbortError") {
+        throw createNetworkError("TIMEOUT", `Request timed out`, url);
+    }
+    const msg = e.message?.toLowerCase() ?? "";
+    if (msg.includes("econnrefused") || msg.includes("connection refused")) {
+        throw createNetworkError("CONNECTION_REFUSED", e.message, url);
+    }
+    if (msg.includes("enotfound") || msg.includes("getaddrinfo") || msg.includes("dns")) {
+        throw createNetworkError("DNS_RESOLUTION_FAILED", e.message, url);
+    }
+    if (msg.includes("ssl") || msg.includes("cert") || msg.includes("tls")) {
+        throw createNetworkError("SSL_ERROR", e.message, url);
+    }
+    throw createNetworkError("CONNECTION_REFUSED", e.message, url);
+}
+function normalizeHeaders(headers) {
+    const result = {};
+    for (const [key, value] of Object.entries(headers)) {
+        result[key.toLowerCase()] = value;
+    }
+    return result;
+}
+async function executeRequest(url, method, headers, body, timeout) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    let currentUrl = url;
+    let redirectsLeft = MAX_REDIRECTS;
+    try {
+        while (true) {
+            const response = await fetch(currentUrl, {
+                method,
+                headers,
+                body,
+                redirect: "manual",
+                signal: controller.signal,
+            });
+            // Handle redirects manually (limit to MAX_REDIRECTS)
+            if ((response.status === 301 || response.status === 302) && redirectsLeft > 0) {
+                const location = response.headers.get("location");
+                if (location) {
+                    currentUrl = location.startsWith("http")
+                        ? location
+                        : new URL(location, currentUrl).toString();
+                    redirectsLeft--;
+                    // For redirects, switch to GET and drop body per HTTP spec
+                    method = "GET";
+                    body = undefined;
+                    delete headers["content-length"];
+                    continue;
+                }
+            }
+            // Normalize response headers
+            const responseHeaders = {};
+            response.headers.forEach((value, key) => {
+                responseHeaders[key.toLowerCase()] = value;
+            });
+            // Deserialize body
+            const contentType = responseHeaders["content-type"] ?? "";
+            let responseBody;
+            if (contentType.includes("application/json")) {
+                const text = await response.text();
+                responseBody = text.length === 0 ? null : JSON.parse(text);
+            }
+            else {
+                responseBody = await response.text();
+            }
+            return { status: response.status, headers: responseHeaders, body: responseBody };
+        }
+    }
+    catch (err) {
+        mapNetworkError(err, url);
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+async function executeWithRetry(url, method, headers, body, timeout, retriesLeft) {
+    try {
+        return await executeRequest(url, method, headers, body, timeout);
+    }
+    catch (err) {
+        if (retriesLeft > 0 && err.error === "NetworkError") {
+            return executeWithRetry(url, method, headers, body, timeout, retriesLeft - 1);
+        }
+        throw err;
+    }
+}
+class HttpRequestResource {
+    manifest;
+    ctx;
+    constructor(manifest, ctx) {
+        this.manifest = manifest;
+        this.ctx = ctx;
+    }
+    async invoke(input) {
+        const ctx = this.ctx;
+        const m = this.manifest;
+        // Resolve client config
+        let clientBaseUrl = "";
+        let clientHeaders = {};
+        let clientTimeout = DEFAULT_TIMEOUT;
+        if (m.client) {
+            const clientName = ctx.expandValue(m.client, input ?? {});
+            const client = ctx.getResourcesByName("Client", clientName);
+            if (!client) {
+                throw new Error(`Http.Client "${clientName}" not found`);
+            }
+            clientBaseUrl = client.baseUrl ?? "";
+            clientHeaders = normalizeHeaders(client.headers ?? {});
+            clientTimeout = client.timeout ?? DEFAULT_TIMEOUT;
+        }
+        // Expand template fields
+        const rawUrl = ctx.expandValue(m.url, input ?? {});
+        const method = (ctx.expandValue(m.method ?? "GET", input ?? {}) || "GET").toUpperCase();
+        const requestHeaders = normalizeHeaders(ctx.expandValue(m.headers ?? {}, input ?? {}) ?? {});
+        const query = ctx.expandValue(m.query ?? {}, input ?? {}) ?? {};
+        const body = m.body !== undefined ? ctx.expandValue(m.body, input ?? {}) : undefined;
+        const effectiveTimeout = m.timeout ?? clientTimeout;
+        const retries = m.retries ?? 0;
+        const throwOnHttpError = m.throwOnHttpError ?? false;
+        // Build URL
+        let fullUrl = rawUrl.startsWith("http") ? rawUrl : `${clientBaseUrl}${rawUrl}`;
+        // Append query params
+        const queryEntries = Object.entries(query);
+        if (queryEntries.length > 0) {
+            const params = new URLSearchParams(queryEntries);
+            fullUrl = `${fullUrl}${fullUrl.includes("?") ? "&" : "?"}${params.toString()}`;
+        }
+        // Merge headers: client defaults < request-specific
+        const mergedHeaders = { ...clientHeaders, ...requestHeaders };
+        // Serialize body
+        let serializedBody;
+        if (body !== undefined) {
+            if (typeof body === "object" && body !== null) {
+                const contentType = mergedHeaders["content-type"] ?? "application/json";
+                if (!mergedHeaders["content-type"]) {
+                    mergedHeaders["content-type"] = "application/json";
+                }
+                if (contentType.includes("application/x-www-form-urlencoded")) {
+                    serializedBody = new URLSearchParams(body).toString();
+                }
+                else {
+                    // Default to JSON
+                    mergedHeaders["content-type"] = mergedHeaders["content-type"] ?? "application/json";
+                    serializedBody = JSON.stringify(body);
+                }
+            }
+            else {
+                serializedBody = String(body);
+            }
+        }
+        const response = await executeWithRetry(fullUrl, method, mergedHeaders, serializedBody, effectiveTimeout, retries);
+        if (throwOnHttpError && response.status >= 400) {
+            throw new Error(`HTTP ${response.status} error from ${fullUrl}`);
+        }
+        return response;
+    }
+}
+export function register() { }
+export async function create(resource, ctx) {
+    return new HttpRequestResource(resource, ctx);
+}

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@telorun/http-client",
+  "version": "0.1.1",
+  "type": "module",
+  "exports": {
+    "./http-client": {
+      "bun": "./src/http-client-controller.ts",
+      "import": "./dist/http-client-controller.js"
+    },
+    "./http-request": {
+      "bun": "./src/http-request-controller.ts",
+      "import": "./dist/http-request-controller.js"
+    }
+  },
+  "files": [
+    "dist/**"
+  ],
+  "dependencies": {
+    "@telorun/sdk": "0.2.5"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.lib.json"
+  }
+}