vigthoria-cli 1.9.2 → 1.9.5

package/dist/utils/tools.d.ts

@@ -14,6 +14,17 @@
  * @author Vigthoria Labs
  */
 import { Logger } from './logger.js';
+export type StreamChunk = {
+    type: 'text' | 'delta' | 'error';
+    content: string;
+};
+export type UpdateInstallerResult = {
+    success: boolean;
+    platform: string;
+    error?: string;
+};
+export declare function installUpdateWindows(): Promise<UpdateInstallerResult>;
+export declare function robustifyStreamResponse(res: any): AsyncIterable<StreamChunk>;
 export type RiskLevel = 'low' | 'medium' | 'high' | 'critical';
 export type SearchStatus = 'search_matches_found' | 'search_no_matches' | 'search_failed';
 export interface ToolResult {

package/dist/utils/tools.js

@@ -52,12 +52,234 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgenticTools = exports.ToolErrorType = void 0;
+exports.installUpdateWindows = installUpdateWindows;
+exports.robustifyStreamResponse = robustifyStreamResponse;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
 const chalk_1 = __importDefault(require("chalk"));
 const logger_js_1 = require("./logger.js");
 const api_js_1 = require("./api.js");
+const STREAM_RESPONSE_MAX_YIELD_CHARS = 32 * 1024;
+function isNodeError(error) {
+    return error instanceof Error && 'code' in error;
+}
+function resolveWindowsInstallerPath() {
+    const configuredPath = process.env.VIGTHORIA_WINDOWS_INSTALLER || process.env.VIGTHORIA_UPDATE_INSTALLER;
+    if (configuredPath && configuredPath.trim().length > 0) {
+        return path.resolve(configuredPath);
+    }
+    const executableDir = path.dirname(process.execPath);
+    const cwd = process.cwd();
+    const candidates = [
+        path.resolve(cwd, 'dist', 'VigthoriaSetup.exe'),
+        path.resolve(cwd, 'release', 'VigthoriaSetup.exe'),
+        path.resolve(cwd, 'VigthoriaSetup.exe'),
+        path.resolve(executableDir, 'VigthoriaSetup.exe'),
+        path.resolve(executableDir, '..', 'VigthoriaSetup.exe'),
+    ];
+    return candidates.find((candidate) => fs.existsSync(candidate)) ?? candidates[0];
+}
+async function installUpdateWindows() {
+    const installerPath = resolveWindowsInstallerPath();
+    try {
+        if (!fs.existsSync(installerPath)) {
+            return { success: false, platform: 'windows', error: 'ENOENT' };
+        }
+        await fs.promises.access(installerPath, fs.constants.F_OK);
+        await new Promise((resolve, reject) => {
+            const child = (0, child_process_1.spawn)(installerPath, [], {
+                cwd: path.dirname(installerPath),
+                detached: true,
+                stdio: 'ignore',
+                windowsHide: false,
+            });
+            child.once('error', reject);
+            child.once('spawn', () => {
+                child.unref();
+                resolve();
+            });
+        });
+        return { success: true, platform: 'windows' };
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === 'ENOENT') {
+            return { success: false, platform: 'windows', error: 'ENOENT' };
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        return { success: false, platform: 'windows', error: message };
+    }
+}
+async function* robustifyStreamResponse(res) {
+    const MAX_YIELD_CHARS = STREAM_RESPONSE_MAX_YIELD_CHARS;
+    const MAX_BUFFER_CHARS = 256 * 1024;
+    const body = res?.body ?? res;
+    const decoder = new TextDecoder('utf-8');
+    let reader = null;
+    let lineBuffer = '';
+    const emitContent = async function* (type, content) {
+        for (let offset = 0; offset < content.length; offset += MAX_YIELD_CHARS) {
+            const part = content.slice(offset, offset + MAX_YIELD_CHARS);
+            if (part.length > 0) {
+                yield { type, content: part };
+            }
+        }
+    };
+    const textFromObject = (value) => {
+        if (!value || typeof value !== 'object')
+            return '';
+        if (typeof value.content === 'string')
+            return value.content;
+        if (typeof value.text === 'string')
+            return value.text;
+        if (typeof value.delta === 'string')
+            return value.delta;
+        if (typeof value.delta?.text === 'string')
+            return value.delta.text;
+        if (typeof value.message?.content === 'string')
+            return value.message.content;
+        if (typeof value.choices?.[0]?.delta?.content === 'string')
+            return value.choices[0].delta.content;
+        if (typeof value.choices?.[0]?.message?.content === 'string')
+            return value.choices[0].message.content;
+        if (typeof value.error === 'string')
+            return value.error;
+        if (typeof value.error?.message === 'string')
+            return value.error.message;
+        return '';
+    };
+    const stringifyChunk = (chunk) => {
+        if (typeof chunk === 'string')
+            return chunk;
+        if (Buffer.isBuffer(chunk))
+            return chunk.toString('utf8');
+        if (chunk instanceof Uint8Array)
+            return Buffer.from(chunk).toString('utf8');
+        if (chunk instanceof ArrayBuffer)
+            return Buffer.from(chunk).toString('utf8');
+        if (chunk === null || chunk === undefined)
+            return '';
+        const objectText = textFromObject(chunk);
+        return objectText || String(chunk);
+    };
+    const decodeLine = (line) => {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed === 'event: ping' || trimmed === ':' || trimmed === 'data: [DONE]' || trimmed === '[DONE]') {
+            return null;
+        }
+        const payload = trimmed.startsWith('data:') ? trimmed.slice(5).trimStart() : trimmed;
+        if (!payload || payload === '[DONE]')
+            return null;
+        if ((payload.startsWith('{') && payload.endsWith('}')) || (payload.startsWith('[') && payload.endsWith(']'))) {
+            try {
+                const parsed = JSON.parse(payload);
+                const parsedText = textFromObject(parsed);
+                if (parsedText) {
+                    const type = parsed.error ? 'error' : 'delta';
+                    return { type, content: parsedText };
+                }
+            }
+            catch (error) {
+                console.debug(`Stream JSON fragment preserved as text: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        if (payload.startsWith('event:') || payload.startsWith('id:') || payload.startsWith('retry:')) {
+            return null;
+        }
+        return { type: 'delta', content: payload };
+    };
+    const consumeText = async function* (text, flush = false) {
+        if (text) {
+            lineBuffer += text;
+        }
+        while (lineBuffer.length > MAX_BUFFER_CHARS) {
+            const newlineIndex = lineBuffer.indexOf('\n', Math.max(0, MAX_BUFFER_CHARS - MAX_YIELD_CHARS));
+            const cutIndex = newlineIndex >= 0 ? newlineIndex + 1 : MAX_BUFFER_CHARS;
+            const overflow = lineBuffer.slice(0, cutIndex);
+            lineBuffer = lineBuffer.slice(cutIndex);
+            const decoded = decodeLine(overflow);
+            if (decoded) {
+                yield* emitContent(decoded.type, decoded.content);
+            }
+            else {
+                yield* emitContent('delta', overflow);
+            }
+        }
+        const lines = lineBuffer.split(/\r?\n/);
+        const partialLine = lines.pop() ?? '';
+        for (const line of lines) {
+            const decoded = decodeLine(line);
+            if (decoded) {
+                yield* emitContent(decoded.type, decoded.content);
+            }
+        }
+        if (flush) {
+            lineBuffer = '';
+            if (partialLine) {
+                const decoded = decodeLine(partialLine);
+                if (decoded) {
+                    yield* emitContent(decoded.type, decoded.content);
+                }
+            }
+        }
+        else {
+            lineBuffer = partialLine;
+        }
+    };
+    try {
+        if (!body) {
+            return;
+        }
+        if (typeof body.getReader === 'function') {
+            reader = body.getReader();
+            const streamReader = reader;
+            const decoder = new TextDecoder();
+            while (true) {
+                const { done, value } = await streamReader.read();
+                if (done)
+                    break;
+                const content = decoder.decode(value, { stream: true });
+                if (content.length > 0) {
+                    yield* consumeText(content);
+                }
+            }
+            const tail = decoder.decode();
+            if (tail.length > 0) {
+                yield* consumeText(tail);
+            }
+            yield* consumeText('', true);
+            return;
+        }
+        if (typeof body[Symbol.asyncIterator] === 'function') {
+            for await (const chunk of body) {
+                const content = stringifyChunk(chunk);
+                if (content.length > 0) {
+                    yield* consumeText(content);
+                }
+            }
+            yield* consumeText('', true);
+            return;
+        }
+        const content = stringifyChunk(body);
+        if (content.length > 0) {
+            yield* emitContent('text', content);
+        }
+    }
+    catch (error) {
+        const content = error instanceof Error ? error.message : String(error);
+        yield { type: 'error', content };
+    }
+    finally {
+        lineBuffer = '';
+        try {
+            reader?.releaseLock();
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.debug(`Stream reader release failed: ${message}`);
+        }
+    }
+}
 const TOOL_ARG_ALIASES = {
     read_file: {
         path: ['file', 'filePath', 'filepath', 'target', 'targetPath'],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vigthoria-cli",
-  "version": "1.9.2",
+  "version": "1.9.5",
   "description": "Vigthoria Coder CLI - AI-powered terminal coding assistant",
   "main": "dist/index.js",
   "files": [
@@ -9,6 +9,12 @@
     "SECURITY_HARDENING.md",
     "CLI_DIRECT_API_ARCHITECTURE.md"
   ],
+  "publishConfig": {
+    "files": [
+      "dist/",
+      "package.json"
+    ]
+  },
   "bin": {
     "vigthoria": "dist/index.js",
     "vig": "dist/index.js",