@swarm-agent/sdk 0.1.47

package/dist/transport.js

@@ -0,0 +1,243 @@
+import { SwarmApiError, SwarmAuthError, SwarmConflictError, SwarmForbiddenError, SwarmNotFoundError, SwarmTimeoutError, } from './errors.js';
+export class SwarmTransport {
+    config;
+    constructor(config) {
+        this.config = { ...config };
+    }
+    setConfig(partial) {
+        this.config = { ...this.config, ...partial };
+    }
+    getConfig() {
+        return { ...this.config };
+    }
+    async request(path, options = {}) {
+        if (options.signal?.aborted)
+            throw new SwarmApiError('Request aborted by caller', { status: 0 });
+        const timeoutMs = options.timeoutMs ?? this.config.timeoutMs;
+        const method = (options.method ?? 'GET').toUpperCase();
+        // Prepare headers
+        const headers = {
+            ...this.config.defaultHeaders,
+            ...options.headers,
+        };
+        if (this.config.token && !headers['Authorization'] && !headers['authorization']) {
+            headers['Authorization'] = `Bearer ${this.config.token}`;
+        }
+        let bodyStr;
+        if (options.body !== undefined && options.body !== null) {
+            if (typeof options.body === 'string') {
+                bodyStr = options.body;
+            }
+            else {
+                bodyStr = JSON.stringify(options.body);
+                if (!headers['Content-Type'] && !headers['content-type']) {
+                    headers['Content-Type'] = 'application/json';
+                }
+            }
+        }
+        // If socketPath is configured, route via Node.js Unix domain socket
+        if (this.config.socketPath) {
+            return this.requestSocket(path, method, headers, bodyStr, timeoutMs, options.signal);
+        }
+        // Standard HTTP/HTTPS via fetch
+        return this.requestFetch(path, method, headers, bodyStr, timeoutMs, options.signal);
+    }
+    async requestFetch(path, method, headers, bodyStr, timeoutMs, externalSignal) {
+        const url = `${this.config.baseUrl.replace(/\/+$/, '')}${path.startsWith('/') ? path : `/${path}`}`;
+        const controller = new AbortController();
+        let timeoutId;
+        if (timeoutMs > 0) {
+            timeoutId = setTimeout(() => {
+                controller.abort(new SwarmTimeoutError(`Request timed out after ${timeoutMs}ms`, timeoutMs));
+            }, timeoutMs);
+        }
+        const abortHandler = () => controller.abort(externalSignal?.reason);
+        if (externalSignal) {
+            externalSignal.addEventListener('abort', abortHandler, { once: true });
+            if (externalSignal.aborted)
+                abortHandler();
+        }
+        try {
+            const res = await fetch(url, {
+                method,
+                headers,
+                body: bodyStr,
+                signal: controller.signal,
+                // Never forward SDK credentials or mutation bodies through redirects.
+                redirect: 'error',
+            });
+            const rawText = await res.text();
+            const responseHeaders = {};
+            res.headers.forEach((v, k) => {
+                responseHeaders[k.toLowerCase()] = v;
+            });
+            let data;
+            try {
+                data = (rawText.length > 0 ? JSON.parse(rawText) : null);
+            }
+            catch {
+                data = rawText;
+            }
+            if (!res.ok) {
+                this.handleErrorResponse(res.status, data, rawText);
+            }
+            return {
+                status: res.status,
+                headers: responseHeaders,
+                data,
+                rawText,
+            };
+        }
+        catch (err) {
+            if (err instanceof SwarmTimeoutError) {
+                throw err;
+            }
+            if (err instanceof Error && err.name === 'AbortError') {
+                if (externalSignal?.aborted) {
+                    throw new SwarmApiError('Request aborted by caller', { status: 0 });
+                }
+                throw new SwarmTimeoutError(`Request timed out after ${timeoutMs}ms`, timeoutMs);
+            }
+            if (err instanceof SwarmApiError) {
+                throw err;
+            }
+            throw new SwarmApiError(err instanceof Error ? err.message : String(err), {
+                status: 0,
+                details: err,
+            });
+        }
+        finally {
+            if (timeoutId)
+                clearTimeout(timeoutId);
+            if (externalSignal)
+                externalSignal.removeEventListener('abort', abortHandler);
+        }
+    }
+    async requestSocket(path, method, headers, bodyStr, timeoutMs, externalSignal) {
+        let httpModule;
+        try {
+            // Dynamic import using variable to avoid static compile-time module resolution
+            const mod = 'node:http';
+            httpModule = await import(mod);
+        }
+        catch {
+            throw new SwarmApiError('Unix domain socket transport requires Node.js runtime', { status: 0 });
+        }
+        return new Promise((resolve, reject) => {
+            const formattedPath = path.startsWith('/') ? path : `/${path}`;
+            const reqHeaders = { ...headers };
+            if (bodyStr !== undefined) {
+                const byteLength = typeof Buffer !== 'undefined'
+                    ? Buffer.byteLength(bodyStr)
+                    : new TextEncoder().encode(bodyStr).length;
+                reqHeaders['Content-Length'] = byteLength.toString();
+            }
+            const req = httpModule.request({
+                socketPath: this.config.socketPath,
+                path: formattedPath,
+                method,
+                headers: reqHeaders,
+                timeout: timeoutMs > 0 ? timeoutMs : undefined,
+            }, (res) => {
+                const chunks = [];
+                res.on('data', (chunk) => chunks.push(chunk));
+                res.on('end', () => {
+                    let rawText = '';
+                    if (typeof Buffer !== 'undefined') {
+                        rawText = Buffer.concat(chunks).toString('utf8');
+                    }
+                    else {
+                        rawText = chunks.map((c) => String(c)).join('');
+                    }
+                    const responseHeaders = {};
+                    for (const [k, v] of Object.entries(res.headers || {})) {
+                        if (v)
+                            responseHeaders[k.toLowerCase()] = Array.isArray(v) ? v.join(', ') : String(v);
+                    }
+                    let data;
+                    try {
+                        data = (rawText.length > 0 ? JSON.parse(rawText) : null);
+                    }
+                    catch {
+                        data = rawText;
+                    }
+                    const status = res.statusCode || 200;
+                    if (status >= 400) {
+                        try {
+                            this.handleErrorResponse(status, data, rawText);
+                        }
+                        catch (apiErr) {
+                            return reject(apiErr);
+                        }
+                    }
+                    resolve({
+                        status,
+                        headers: responseHeaders,
+                        data,
+                        rawText,
+                    });
+                });
+            });
+            if (timeoutMs > 0) {
+                req.on('timeout', () => {
+                    req.destroy(new SwarmTimeoutError(`Socket request timed out after ${timeoutMs}ms`, timeoutMs));
+                });
+            }
+            req.on('error', (err) => {
+                if (err instanceof SwarmTimeoutError) {
+                    return reject(err);
+                }
+                reject(new SwarmApiError(`Socket error: ${err?.message || String(err)}`, { status: 0, details: err }));
+            });
+            const abort = () => req.destroy(new SwarmApiError('Request aborted by caller', { status: 0 }));
+            externalSignal?.addEventListener('abort', abort, { once: true });
+            req.on('close', () => externalSignal?.removeEventListener('abort', abort));
+            if (externalSignal?.aborted) {
+                abort();
+                return;
+            }
+            if (bodyStr !== undefined) {
+                req.write(bodyStr);
+            }
+            req.end();
+        });
+    }
+    handleErrorResponse(status, data, rawText) {
+        let message = `API request failed with status ${status}`;
+        let code;
+        let details = undefined;
+        if (data && typeof data === 'object') {
+            const obj = data;
+            if (typeof obj.error === 'string' && obj.error) {
+                message = obj.error;
+            }
+            else if (typeof obj.message === 'string' && obj.message) {
+                message = obj.message;
+            }
+            if (typeof obj.code === 'string') {
+                code = obj.code;
+            }
+            details = obj.details ?? obj;
+        }
+        else if (rawText && rawText.length < 200) {
+            message = rawText;
+        }
+        const options = {
+            code,
+            details,
+            responseBody: rawText,
+        };
+        switch (status) {
+            case 401:
+                throw new SwarmAuthError(message, options);
+            case 403:
+                throw new SwarmForbiddenError(message, options);
+            case 404:
+                throw new SwarmNotFoundError(message, options);
+            case 409:
+                throw new SwarmConflictError(message, options);
+            default:
+                throw new SwarmApiError(message, { ...options, status });
+        }
+    }
+}