@beast01/tcurl 1.0.0

package/dist/http/client.js

@@ -0,0 +1,190 @@
+import http from 'node:http';
+import https from 'node:https';
+import { URL } from 'node:url';
+import { Buffer } from 'node:buffer';
+const MAX_REDIRECTS = 10;
+/** Build the fully-resolved URL including enabled query params. */
+export function buildUrl(config) {
+    const url = new URL(config.url);
+    for (const q of config.query) {
+        if (q.enabled && q.key)
+            url.searchParams.append(q.key, q.value);
+    }
+    return url;
+}
+/** Compute the outgoing headers, folding in auth and body content type. */
+export function buildHeaders(config) {
+    const headers = {};
+    for (const h of config.headers) {
+        if (h.enabled && h.key)
+            headers[h.key] = h.value;
+    }
+    const hasHeader = (name) => Object.keys(headers).some((k) => k.toLowerCase() === name.toLowerCase());
+    // Auth
+    if (config.auth.type === 'bearer' && config.auth.token) {
+        if (!hasHeader('authorization'))
+            headers['Authorization'] = `Bearer ${config.auth.token}`;
+    }
+    else if (config.auth.type === 'basic') {
+        if (!hasHeader('authorization')) {
+            const raw = `${config.auth.token}:${config.auth.password}`;
+            headers['Authorization'] = `Basic ${Buffer.from(raw).toString('base64')}`;
+        }
+    }
+    // Default content types by body mode
+    if (config.bodyMode === 'json' && !hasHeader('content-type')) {
+        headers['Content-Type'] = 'application/json';
+    }
+    else if (config.bodyMode === 'form' && !hasHeader('content-type')) {
+        headers['Content-Type'] = 'application/x-www-form-urlencoded';
+    }
+    if (!hasHeader('accept'))
+        headers['Accept'] = '*/*';
+    if (!hasHeader('user-agent'))
+        headers['User-Agent'] = 'tcurl/1.0';
+    return headers;
+}
+/** Serialize the request body according to its mode. */
+export function buildBody(config) {
+    const methodHasBody = !['GET', 'HEAD'].includes(config.method);
+    if (!methodHasBody || config.bodyMode === 'none')
+        return undefined;
+    if (config.bodyMode === 'form') {
+        // body holds `key=value` lines; encode them.
+        const params = new URLSearchParams();
+        for (const line of config.body.split('\n')) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            const idx = trimmed.indexOf('=');
+            if (idx === -1)
+                params.append(trimmed, '');
+            else
+                params.append(trimmed.slice(0, idx), trimmed.slice(idx + 1));
+        }
+        return Buffer.from(params.toString());
+    }
+    if (!config.body)
+        return undefined;
+    return Buffer.from(config.body);
+}
+function familyFromContentType(ct) {
+    const lower = ct.toLowerCase();
+    if (lower.includes('json'))
+        return 'json';
+    if (lower.includes('html'))
+        return 'html';
+    if (lower.includes('xml'))
+        return 'xml';
+    if (lower.startsWith('image/'))
+        return 'image';
+    if (lower.startsWith('text/'))
+        return 'text';
+    return 'text';
+}
+function doRequest(opts, redirectsLeft) {
+    return new Promise((resolve, reject) => {
+        const isHttps = opts.url.protocol === 'https:';
+        const transport = isHttps ? https : http;
+        const reqOptions = {
+            method: opts.method,
+            hostname: opts.url.hostname,
+            port: opts.url.port || (isHttps ? 443 : 80),
+            path: opts.url.pathname + opts.url.search,
+            headers: opts.headers,
+            rejectUnauthorized: opts.rejectUnauthorized,
+            signal: opts.signal,
+        };
+        const req = transport.request(reqOptions, (res) => {
+            const status = res.statusCode ?? 0;
+            // Handle redirects manually so we can honor the follow setting.
+            if (opts.followRedirects &&
+                redirectsLeft > 0 &&
+                [301, 302, 303, 307, 308].includes(status) &&
+                res.headers.location) {
+                res.resume(); // drain
+                const nextUrl = new URL(res.headers.location, opts.url);
+                // 303, or 301/302 on POST, downgrade to GET per browser behavior.
+                let nextMethod = opts.method;
+                let nextBody = opts.body;
+                if (status === 303 || ((status === 301 || status === 302) && opts.method === 'POST')) {
+                    nextMethod = 'GET';
+                    nextBody = undefined;
+                }
+                doRequest({ ...opts, url: nextUrl, method: nextMethod, body: nextBody }, redirectsLeft - 1).then(resolve, reject);
+                return;
+            }
+            const chunks = [];
+            res.on('data', (c) => chunks.push(c));
+            res.on('end', () => {
+                const bodyBuf = Buffer.concat(chunks);
+                const headers = {};
+                for (const [k, v] of Object.entries(res.headers)) {
+                    headers[k] = Array.isArray(v) ? v.join(', ') : String(v ?? '');
+                }
+                const ct = headers['content-type'] ?? '';
+                resolve({
+                    ok: status >= 200 && status < 400,
+                    status,
+                    statusText: res.statusMessage ?? '',
+                    headers,
+                    body: bodyBuf.toString('utf8'),
+                    contentType: familyFromContentType(ct),
+                    sizeBytes: bodyBuf.length,
+                    finalUrl: opts.url.toString(),
+                });
+            });
+        });
+        req.on('error', (err) => reject(err));
+        if (opts.body)
+            req.write(opts.body);
+        req.end();
+    });
+}
+/** Execute a request config and return a normalized result (never throws). */
+export async function executeRequest(config) {
+    const start = Date.now();
+    const controller = new AbortController();
+    let timer;
+    if (config.timeoutMs > 0) {
+        timer = setTimeout(() => controller.abort(), config.timeoutMs);
+    }
+    try {
+        const url = buildUrl(config);
+        if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+            throw new Error(`Unsupported protocol: ${url.protocol}`);
+        }
+        const result = await doRequest({
+            url,
+            method: config.method,
+            headers: buildHeaders(config),
+            body: buildBody(config),
+            timeoutMs: config.timeoutMs,
+            rejectUnauthorized: config.rejectUnauthorized,
+            followRedirects: config.followRedirects,
+            signal: controller.signal,
+        }, MAX_REDIRECTS);
+        return { ...result, durationMs: Date.now() - start };
+    }
+    catch (err) {
+        const aborted = err?.name === 'AbortError' || controller.signal.aborted;
+        return {
+            ok: false,
+            status: 0,
+            statusText: '',
+            headers: {},
+            body: '',
+            contentType: 'text',
+            durationMs: Date.now() - start,
+            sizeBytes: 0,
+            finalUrl: config.url,
+            error: aborted
+                ? `Request timed out after ${config.timeoutMs}ms`
+                : String(err?.message ?? err),
+        };
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}

package/dist/lib/curlgen.js

@@ -0,0 +1,40 @@
+import { buildUrl, buildHeaders, buildBody } from '../http/client.js';
+function shellQuote(value) {
+    // Wrap in single quotes, escaping embedded single quotes.
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+/** Render a request config as an equivalent `curl` command line. */
+export function toCurl(config) {
+    const parts = ['curl'];
+    if (config.method !== 'GET')
+        parts.push('-X', config.method);
+    let url;
+    try {
+        url = buildUrl(config).toString();
+    }
+    catch {
+        url = config.url;
+    }
+    parts.push(shellQuote(url));
+    const headers = buildHeaders(config);
+    for (const [k, v] of Object.entries(headers)) {
+        parts.push('-H', shellQuote(`${k}: ${v}`));
+    }
+    const body = buildBody(config);
+    if (body && body.length > 0) {
+        parts.push('--data', shellQuote(body.toString('utf8')));
+    }
+    if (!config.followRedirects) {
+        /* curl does not follow by default; nothing to add */
+    }
+    else {
+        parts.push('-L');
+    }
+    if (!config.rejectUnauthorized)
+        parts.push('-k');
+    if (config.timeoutMs > 0) {
+        parts.push('--max-time', String(Math.ceil(config.timeoutMs / 1000)));
+    }
+    // Join with line continuations for readability.
+    return parts.join(' ');
+}

package/dist/lib/format.js

@@ -0,0 +1,41 @@
+/** Pretty-print a body based on its detected content family. */
+export function prettyBody(body, family) {
+    if (family === 'json') {
+        try {
+            return JSON.stringify(JSON.parse(body), null, 2);
+        }
+        catch {
+            return body;
+        }
+    }
+    return body;
+}
+export function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+}
+export function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms} ms`;
+    return `${(ms / 1000).toFixed(2)} s`;
+}
+/** Split a string into wrapped lines of at most `width` columns. */
+export function wrapLines(text, width) {
+    const out = [];
+    for (const rawLine of text.split('\n')) {
+        if (rawLine.length <= width) {
+            out.push(rawLine);
+            continue;
+        }
+        let line = rawLine;
+        while (line.length > width) {
+            out.push(line.slice(0, width));
+            line = line.slice(width);
+        }
+        out.push(line);
+    }
+    return out;
+}

package/dist/lib/id.js

@@ -0,0 +1,4 @@
+import { randomUUID } from 'node:crypto';
+export function newId() {
+    return randomUUID();
+}

package/dist/lib/kv.js

@@ -0,0 +1,54 @@
+/** Render header pairs as `Key: Value` lines for text editing. */
+export function headersToText(headers) {
+    return headers
+        .filter((h) => h.enabled)
+        .map((h) => `${h.key}: ${h.value}`)
+        .join('\n');
+}
+export function textToHeaders(text) {
+    const out = [];
+    for (const line of text.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        const idx = trimmed.indexOf(':');
+        if (idx === -1) {
+            out.push({ key: trimmed, value: '', enabled: true });
+        }
+        else {
+            out.push({
+                key: trimmed.slice(0, idx).trim(),
+                value: trimmed.slice(idx + 1).trim(),
+                enabled: true,
+            });
+        }
+    }
+    return out;
+}
+/** Render query pairs as `key=value` lines for text editing. */
+export function queryToText(query) {
+    return query
+        .filter((q) => q.enabled)
+        .map((q) => `${q.key}=${q.value}`)
+        .join('\n');
+}
+export function textToQuery(text) {
+    const out = [];
+    for (const line of text.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        const idx = trimmed.indexOf('=');
+        if (idx === -1) {
+            out.push({ key: trimmed, value: '', enabled: true });
+        }
+        else {
+            out.push({
+                key: trimmed.slice(0, idx).trim(),
+                value: trimmed.slice(idx + 1).trim(),
+                enabled: true,
+            });
+        }
+    }
+    return out;
+}

package/dist/storage.js

@@ -0,0 +1,78 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import envPaths from 'env-paths';
+import { newId } from './lib/id.js';
+const paths = envPaths('tcurl', { suffix: '' });
+const STORE_DIR = paths.config;
+const STORE_FILE = path.join(STORE_DIR, 'store.json');
+const STORE_VERSION = 1;
+function emptyStore() {
+    return { version: STORE_VERSION, requests: [], theme: 'gruvbox' };
+}
+export function defaultRequest(partial = {}) {
+    const now = Date.now();
+    return {
+        id: newId(),
+        name: 'Untitled request',
+        method: 'GET',
+        url: '',
+        headers: [],
+        query: [],
+        bodyMode: 'none',
+        body: '',
+        auth: { type: 'none', token: '', password: '' },
+        timeoutMs: 30000,
+        followRedirects: true,
+        rejectUnauthorized: true,
+        createdAt: now,
+        updatedAt: now,
+        ...partial,
+    };
+}
+/** Migrate/normalize a stored request so older files stay loadable. */
+function normalizeRequest(raw) {
+    const base = defaultRequest();
+    return {
+        ...base,
+        ...raw,
+        auth: { ...base.auth, ...(raw?.auth ?? {}) },
+        headers: Array.isArray(raw?.headers) ? raw.headers : [],
+        query: Array.isArray(raw?.query) ? raw.query : [],
+    };
+}
+export async function loadStore() {
+    try {
+        const text = await fs.readFile(STORE_FILE, 'utf8');
+        const parsed = JSON.parse(text);
+        return {
+            version: STORE_VERSION,
+            theme: typeof parsed.theme === 'string' ? parsed.theme : 'gruvbox',
+            requests: Array.isArray(parsed.requests)
+                ? parsed.requests.map(normalizeRequest)
+                : [],
+        };
+    }
+    catch (err) {
+        if (err?.code === 'ENOENT')
+            return emptyStore();
+        // Corrupt file: back it up and start fresh rather than crashing.
+        try {
+            await fs.rename(STORE_FILE, `${STORE_FILE}.corrupt-${Date.now()}`);
+        }
+        catch {
+            /* ignore */
+        }
+        return emptyStore();
+    }
+}
+export async function saveStore(store) {
+    await fs.mkdir(STORE_DIR, { recursive: true });
+    const tmp = `${STORE_FILE}.tmp-${process.pid}`;
+    const data = JSON.stringify(store, null, 2);
+    // Write atomically so a crash mid-write can't corrupt the store.
+    await fs.writeFile(tmp, data, 'utf8');
+    await fs.rename(tmp, STORE_FILE);
+}
+export function storeLocation() {
+    return STORE_FILE;
+}

package/dist/theme.js

@@ -0,0 +1,73 @@
+/** Gruvbox dark — https://github.com/morhetz/gruvbox */
+export const gruvbox = {
+    name: 'gruvbox',
+    bg: '#282828',
+    fg: '#ebdbb2',
+    fgDim: '#a89984',
+    accent: '#fabd2f', // yellow
+    accentAlt: '#83a598', // blue
+    success: '#b8bb26', // green
+    warning: '#fe8019', // orange
+    error: '#fb4934', // red
+    info: '#8ec07c', // aqua
+    muted: '#665c54',
+    selectionBg: '#3c3836',
+    border: '#504945',
+    borderActive: '#fabd2f',
+};
+/** Ember — a warm, glowing dark palette. */
+export const ember = {
+    name: 'ember',
+    bg: '#1b1206',
+    fg: '#f5e6c8',
+    fgDim: '#c9a36a',
+    accent: '#ff9e3b', // ember orange
+    accentAlt: '#ffcf70', // amber
+    success: '#c2d94c', // lime
+    warning: '#ffb454', // amber-orange
+    error: '#f07178', // coral
+    info: '#e6a15c', // tan
+    muted: '#6b4f2a',
+    selectionBg: '#2a1c0a',
+    border: '#4d3616',
+    borderActive: '#ff9e3b',
+};
+export const themes = {
+    gruvbox,
+    ember,
+};
+export function getTheme(name) {
+    return themes[name] ?? gruvbox;
+}
+/** A stable color per HTTP method for at-a-glance scanning. */
+export function methodColor(method, theme) {
+    switch (method) {
+        case 'GET':
+            return theme.success;
+        case 'POST':
+            return theme.accent;
+        case 'PUT':
+            return theme.accentAlt;
+        case 'PATCH':
+            return theme.info;
+        case 'DELETE':
+            return theme.error;
+        case 'HEAD':
+        case 'OPTIONS':
+            return theme.fgDim;
+        default:
+            return theme.fg;
+    }
+}
+/** Color for an HTTP status code by class. */
+export function statusColor(status, theme) {
+    if (status >= 200 && status < 300)
+        return theme.success;
+    if (status >= 300 && status < 400)
+        return theme.accentAlt;
+    if (status >= 400 && status < 500)
+        return theme.warning;
+    if (status >= 500)
+        return theme.error;
+    return theme.fgDim;
+}

package/dist/types.js

@@ -0,0 +1,9 @@
+export const HTTP_METHODS = [
+    'GET',
+    'POST',
+    'PUT',
+    'PATCH',
+    'DELETE',
+    'HEAD',
+    'OPTIONS',
+];

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@beast01/tcurl",
+  "version": "1.0.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "An interactive terminal UI (TUI) for building, sending, and saving HTTP requests — curl, but comfortable.",
+  "type": "module",
+  "bin": {
+    "tcurl": "dist/cli.js"
+  },
+  "main": "dist/cli.js",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsc -p tsconfig.json --watch",
+    "start": "node dist/cli.js",
+    "prepublishOnly": "npm run build",
+    "clean": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\""
+  },
+  "keywords": [
+    "curl",
+    "tui",
+    "terminal",
+    "http",
+    "rest",
+    "client",
+    "api",
+    "ink",
+    "cli",
+    "postman",
+    "httpie",
+    "gruvbox"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "env-paths": "^3.0.0",
+    "ink": "^5.0.1",
+    "react": "^18.3.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.20.0",
+    "@types/react": "^18.3.12",
+    "typescript": "^5.6.3"
+  }
+}