@llmtune/cli 0.1.8 → 0.1.9

package/dist/tools/tools/web-fetch.js

@@ -7,24 +7,20 @@ exports.webFetchTool = void 0;
 const https_1 = __importDefault(require("https"));
 const http_1 = __importDefault(require("http"));
 const version_1 = require("../../version");
+const sanitize_1 = require("../sanitize");
 const MAX_RESPONSE_SIZE = 500_000;
 const TIMEOUT_MS = 30_000;
+const MAX_REDIRECTS = 5;
 exports.webFetchTool = {
     spec() {
         return {
             name: "web-fetch",
-            description: "Fetch content from a URL. Returns the response body as text. Supports HTTP and HTTPS. Use for reading web pages, API responses, or documentation.",
+            description: "Fetch content from a URL. Returns the response body as text. Supports HTTP and HTTPS.",
             inputSchema: {
                 type: "object",
                 properties: {
-                    url: {
-                        type: "string",
-                        description: "The URL to fetch (http:// or https://)",
-                    },
-                    method: {
-                        type: "string",
-                        description: "HTTP method (default: GET)",
-                    },
+                    url: { type: "string", description: "The URL to fetch (http:// or https://)" },
+                    method: { type: "string", description: "HTTP method (default: GET)" },
                     headers: {
                         type: "object",
                         description: "Optional request headers as key-value pairs",
@@ -35,109 +31,88 @@ exports.webFetchTool = {
             isReadOnly: true,
         };
     },
-    run(input, _ctx) {
+    async run(input, _ctx) {
         const url = String(input.url ?? "");
-        const method = String(input.method ?? "GET").toUpperCase();
-        const headers = input.headers ?? {};
+        const method = String(input.method || "GET").toUpperCase();
+        const headers = input.headers || {};
+        const redirectCount = parseInt(String(input._redirectCount || "0"), 10);
         if (!url) {
-            return Promise.resolve({
-                name: "web-fetch",
-                output: { error: "url is required" },
-                isError: true,
-            });
+            return { name: "web-fetch", output: { error: "url is required" }, isError: true };
         }
-        let parsedUrl;
         try {
-            parsedUrl = new URL(url);
+            (0, sanitize_1.sanitizeUrl)(url);
         }
-        catch {
-            return Promise.resolve({
-                name: "web-fetch",
-                output: { error: `Invalid URL: ${url}` },
-                isError: true,
-            });
+        catch (err) {
+            return { name: "web-fetch", output: { error: err.message }, isError: true };
         }
-        if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") {
-            return Promise.resolve({
-                name: "web-fetch",
-                output: { error: `Unsupported protocol: ${parsedUrl.protocol}. Use http:// or https://` },
-                isError: true,
-            });
+        const result = await doFetch(url, method, headers);
+        if (result._redirect) {
+            if (redirectCount >= MAX_REDIRECTS) {
+                return { name: "web-fetch", output: { error: `Too many redirects (max ${MAX_REDIRECTS})` }, isError: true };
+            }
+            try {
+                (0, sanitize_1.sanitizeUrl)(result._redirect);
+            }
+            catch (err) {
+                return { name: "web-fetch", output: { error: `Redirect to blocked URL: ${err.message}` }, isError: true };
+            }
+            return exports.webFetchTool.run({ ...input, url: result._redirect, _redirectCount: redirectCount + 1 }, _ctx);
         }
-        return new Promise((resolve) => {
-            const lib = parsedUrl.protocol === "https:" ? https_1.default : http_1.default;
-            const req = lib.request(url, {
-                method,
-                headers: {
-                    "User-Agent": `LLMTune-CLI/${version_1.CLI_VERSION}`,
-                    Accept: "text/html,application/json,text/plain,*/*",
-                    ...headers,
-                },
-                timeout: TIMEOUT_MS,
-            }, (res) => {
-                // Follow redirects (up to 5)
-                if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
-                    const redirectUrl = new URL(res.headers.location, url).toString();
-                    return Promise.resolve(exports.webFetchTool.run({ ...input, url: redirectUrl }, _ctx)).then(resolve);
-                }
-                const chunks = [];
-                let size = 0;
-                res.on("data", (chunk) => {
-                    size += chunk.length;
-                    if (size > MAX_RESPONSE_SIZE) {
-                        req.destroy();
-                        resolve({
-                            name: "web-fetch",
-                            output: {
-                                error: `Response too large (${(size / 1024).toFixed(0)}KB). Maximum is ${MAX_RESPONSE_SIZE / 1024}KB.`,
-                            },
-                            isError: true,
-                        });
-                        return;
+        return result;
+    },
+};
+function doFetch(url, method, headers) {
+    return new Promise((resolve) => {
+        const parsedUrl = new URL(url);
+        const httpModule = parsedUrl.protocol === "https:" ? https_1.default : http_1.default;
+        const options = {
+            method,
+            hostname: parsedUrl.hostname,
+            port: parsedUrl.port,
+            path: parsedUrl.pathname + parsedUrl.search,
+            headers: {
+                "User-Agent": `llmtune-cli/${version_1.CLI_VERSION}`,
+                ...headers,
+            },
+            timeout: TIMEOUT_MS,
+        };
+        const req = httpModule.request(options, (res) => {
+            if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                const redirectUrl = new URL(res.headers.location, url).toString();
+                res.resume();
+                resolve({ name: "web-fetch", output: {}, isError: false, _redirect: redirectUrl });
+                return;
+            }
+            let body = "";
+            let truncated = false;
+            res.on("data", (chunk) => {
+                if (!truncated) {
+                    body += chunk.toString();
+                    if (body.length > MAX_RESPONSE_SIZE) {
+                        body = body.slice(0, MAX_RESPONSE_SIZE);
+                        truncated = true;
                     }
-                    chunks.push(chunk);
-                });
-                res.on("end", () => {
-                    const body = Buffer.concat(chunks).toString("utf-8");
-                    const truncated = body.length > 50_000;
-                    const content = truncated ? body.slice(0, 50_000) + "\n... (truncated)" : body;
-                    resolve({
-                        name: "web-fetch",
-                        output: {
-                            url,
-                            status: res.statusCode ?? 0,
-                            contentType: res.headers["content-type"] ?? "unknown",
-                            content,
-                            truncated,
-                        },
-                        isError: false,
-                    });
-                });
-                res.on("error", (err) => {
-                    resolve({
-                        name: "web-fetch",
-                        output: { error: `Response error: ${err.message}` },
-                        isError: true,
-                    });
-                });
+                }
             });
-            req.on("error", (err) => {
+            res.on("end", () => {
                 resolve({
                     name: "web-fetch",
-                    output: { error: `Request failed: ${err.message}` },
-                    isError: true,
+                    output: { url, status: res.statusCode, content: body, truncated },
+                    isError: false,
                 });
             });
-            req.on("timeout", () => {
-                req.destroy();
-                resolve({
-                    name: "web-fetch",
-                    output: { error: `Request timed out after ${TIMEOUT_MS / 1000}s` },
-                    isError: true,
-                });
+            res.on("error", (err) => {
+                resolve({ name: "web-fetch", output: { error: `Response error: ${err.message}` }, isError: true });
             });
-            req.end();
         });
-    },
-};
+        req.on("error", (err) => {
+            resolve({ name: "web-fetch", output: { error: `Request error: ${err.message}` }, isError: true });
+        });
+        req.on("timeout", () => {
+            req.destroy();
+            resolve({ name: "web-fetch", output: { error: `Request timed out after ${TIMEOUT_MS / 1000}s` }, isError: true });
+        });
+        req.end();
+    });
+}
 //# sourceMappingURL=web-fetch.js.map

package/dist/tools/tools/write.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.writeTool = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const sanitize_1 = require("../sanitize");
 exports.writeTool = {
     spec() {
         return {
@@ -54,18 +55,23 @@ exports.writeTool = {
         };
     },
     run(input, ctx) {
-        const filePath = String(input.file_path ?? "");
+        let filePath;
+        try {
+            filePath = (0, sanitize_1.sanitizeFilePath)(String(input.file_path ?? ""), ctx.workspaceRoot);
+        }
+        catch (err) {
+            return { name: "write", output: { error: err.message }, isError: true };
+        }
         const content = String(input.content ?? "");
         const createDirs = input.create_dirs !== false;
-        const absPath = path.resolve(ctx.cwd, filePath);
-        if (!absPath.startsWith(path.resolve(ctx.cwd))) {
-            return { name: "write", output: { error: "Cannot write outside workspace" }, isError: true };
-        }
         try {
             if (createDirs) {
-                fs.mkdirSync(path.dirname(absPath), { recursive: true });
+                const dir = path.dirname(filePath);
+                if (!fs.existsSync(dir)) {
+                    fs.mkdirSync(dir, { recursive: true });
+                }
             }
-            fs.writeFileSync(absPath, content, "utf-8");
+            fs.writeFileSync(filePath, content, "utf-8");
             return {
                 name: "write",
                 output: { type: "file_written", filePath, bytesWritten: Buffer.byteLength(content) },

package/dist/ui/banner.d.ts

@@ -0,0 +1,2 @@
+export declare function renderBanner(): string;
+//# sourceMappingURL=banner.d.ts.map

package/dist/ui/banner.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderBanner = renderBanner;
+const chalk_1 = __importDefault(require("chalk"));
+const version_1 = require("../version");
+/**
+ * LLMTune ASCII art logo — shown on CLI startup and `llmtune` with no args.
+ * Uses only standard ASCII characters for maximum terminal compatibility.
+ */
+const LOGO = [
+    "  _     _     _ _  __       _ _",
+    " | |   | |   | (_)/ _|     | | |",
+    " | |__ | |__ | |_| |_ ___  | | |___ _ __",
+    " | '_ \\| '_ \\| | |  _/ _ \\ | | / _ \\ '__|",
+    " | | | | |_) | | | ||  __/ | ||  __/ |",
+    " |_| |_|_.__/|_|_|_| \\___| |_|\\___|_|",
+].join("\n");
+function renderBanner() {
+    const lines = [];
+    lines.push("");
+    lines.push(chalk_1.default.cyan(LOGO));
+    lines.push(chalk_1.default.dim(`  AI CLI Agent · v${version_1.CLI_VERSION} · llmtune.io`));
+    lines.push("");
+    return lines.join("\n");
+}
+//# sourceMappingURL=banner.js.map

package/dist/utils/streaming.d.ts

@@ -1,10 +1,13 @@
-import { Ora } from "ora";
+/**
+ * Streaming display utilities for throttled terminal output.
+ * IMPORTANT: Every token is preserved — none are dropped between updates.
+ */
 export declare function createStreamingDisplay(): {
     onToken(token: string): void;
+    /** Call when stream ends to flush any remaining buffered tokens */
     flush(): void;
     getBuffer(): string;
 };
-export declare function showSpinner(text: string): Ora;
-export declare function formatToolCall(name: string, input: Record<string, unknown>): string;
+export declare function getToolLabel(name: string, input: Record<string, unknown>): string;
 export declare function formatToolResult(name: string, output: unknown): string;
 //# sourceMappingURL=streaming.d.ts.map

package/dist/utils/streaming.js

@@ -1,8 +1,11 @@
 "use strict";
+/**
+ * Streaming display utilities for throttled terminal output.
+ * IMPORTANT: Every token is preserved — none are dropped between updates.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createStreamingDisplay = createStreamingDisplay;
-exports.showSpinner = showSpinner;
-exports.formatToolCall = formatToolCall;
+exports.getToolLabel = getToolLabel;
 exports.formatToolResult = formatToolResult;
 function createStreamingDisplay() {
     let buffer = "";
@@ -12,14 +15,16 @@ function createStreamingDisplay() {
         onToken(token) {
             buffer += token;
             const now = Date.now();
-            if (now - lastUpdateTime > UPDATE_INTERVAL_MS) {
-                process.stdout.write(token);
+            if (now - lastUpdateTime >= UPDATE_INTERVAL_MS) {
+                process.stdout.write(buffer);
+                buffer = "";
                 lastUpdateTime = now;
             }
         },
+        /** Call when stream ends to flush any remaining buffered tokens */
         flush() {
             if (buffer) {
-                process.stdout.write("\n");
+                process.stdout.write(buffer);
                 buffer = "";
             }
         },
@@ -28,20 +33,10 @@ function createStreamingDisplay() {
         },
     };
 }
-function showSpinner(text) {
-    const ora = require("ora");
-    return ora({ text, color: "cyan" }).start();
-}
-function formatToolCall(name, input) {
-    const summary = summarizeToolInput(name, input);
-    return `  \x1b[33m*\x1b[0m ${name}${summary ? `(${summary})` : ""}`;
-}
-function summarizeToolInput(name, input) {
-    switch (name.toLowerCase()) {
-        case "bash": {
-            const cmd = String(input.command || "");
-            return cmd.length > 60 ? cmd.slice(0, 57) + "..." : cmd;
-        }
+function getToolLabel(name, input) {
+    switch (name) {
+        case "bash":
+            return String(input.command || "");
         case "read":
         case "write":
         case "edit":

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@llmtune/cli",
-  "version": "0.1.8",
-  "description": "LLMTune CLI -AI CLI Agent powered by llmtune.io",
+  "version": "0.1.9",
+  "description": "LLMTune CLI - AI CLI Agent powered by llmtune.io",
   "main": "dist/index.js",
   "bin": {
     "llmtune": "dist/index.js"