vigthoria-cli 1.8.15 → 1.8.19

package/dist/commands/chat.d.ts

@@ -118,8 +118,7 @@ export declare class ChatCommand {
     private runLocalAgentLoop;
     private tryDirectSingleFileFlow;
     private tryV3AgentWorkflow;
-    private isSaaSRescuePrompt;
-    private tryCommandLevelSaaSRescue;
+    private tryRecoverV3ServiceAndRetry;
     private startInteractiveChat;
     private showHelp;
     private showContext;

package/dist/commands/chat.js

@@ -494,6 +494,43 @@ class ChatCommand {
             spinner.text = status === 'planning' ? 'Planning...' : 'Executing plan...';
             return;
         }
+        if (event.type === 'executor_start') {
+            if (spinner.isSpinning)
+                spinner.stop();
+            process.stderr.write(chalk_1.default.cyan('  [Executor] ') + `Starting ${event.task_id || 'task'}${event.title ? ` - ${event.title}` : ''}
+`);
+            spinner.start();
+            spinner.text = 'Vigthoria Executor running...';
+            return;
+        }
+        if (event.type === 'executor_error') {
+            if (spinner.isSpinning)
+                spinner.stop();
+            const msg = (0, api_js_1.sanitizeUserFacingErrorText)(String(event.error || 'Executor error')) || 'Executor error';
+            process.stderr.write(chalk_1.default.red('  [Executor] ') + `Vigthoria Executor encountered an issue: ${msg}
+`);
+            spinner.start();
+            spinner.text = 'Recovering executor...';
+            return;
+        }
+        if (event.type === 'executor_complete') {
+            if (spinner.isSpinning)
+                spinner.stop();
+            const summary = event.summary || {};
+            const status = String(summary.status || 'completed');
+            const changed = Array.isArray(summary.changed_files) ? summary.changed_files.length : 0;
+            if (status === 'failed') {
+                process.stderr.write(chalk_1.default.red('  [Executor] ') + `Vigthoria Executor task failed${summary.task_id ? ` (${summary.task_id})` : ''}.
+`);
+            }
+            else {
+                process.stderr.write(chalk_1.default.green('  [Executor] ') + `Task completed${summary.task_id ? ` (${summary.task_id})` : ''}${changed ? `, ${changed} files changed` : ''}.
+`);
+            }
+            spinner.start();
+            spinner.text = 'Continuing plan...';
+            return;
+        }
         if (event.type === 'file_mutation') {
             const rawPath = typeof event.path === 'string' ? this.sanitizeServerPath(event.path) : '';
             const filePath = rawPath ? rawPath.replace(/\\/g, '/').split('/').slice(-2).join('/') : '';
@@ -516,7 +553,18 @@ class ChatCommand {
             else {
                 if (spinner.isSpinning)
                     spinner.stop();
-                process.stderr.write(chalk_1.default.red('  [Error] ') + (event.message || 'Agent error') + '\n');
+                const message = (0, api_js_1.sanitizeUserFacingErrorText)(String(event.message || 'Agent error')) || 'Agent error';
+                const plannerLike = /plan|planner|dependency graph/i.test(message);
+                const executorLike = /executor|task failed|iteration/i.test(message);
+                if (plannerLike) {
+                    process.stderr.write(chalk_1.default.red('  [Planner] ') + `Vigthoria Planner encountered an issue: ${message}\n`);
+                }
+                else if (executorLike) {
+                    process.stderr.write(chalk_1.default.red('  [Executor] ') + `Vigthoria Executor encountered an issue: ${message}\n`);
+                }
+                else {
+                    process.stderr.write(chalk_1.default.red('  [Error] ') + message + '\n');
+                }
             }
             return;
         }
@@ -1612,7 +1660,6 @@ class ChatCommand {
     async tryV3AgentWorkflow(prompt) {
         const runtimeContext = await this.getPromptRuntimeContext(prompt);
         const routingPolicy = this.resolveAgentExecutionPolicy(prompt);
-        const rescueEligible = this.isSaaSRescuePrompt(prompt);
         // Reset streaming counters for new workflow
         this.v3IterationCount = 0;
         this.v3ToolCallCount = 0;
@@ -1660,14 +1707,7 @@ class ChatCommand {
                 ...runtimeContext,
                 onStreamEvent: spinner ? (event) => this.updateV3AgentSpinner(spinner, event) : undefined,
             });
-            const response = await (rescueEligible && DEFAULT_V3_AGENT_SOFT_TIMEOUT_MS > 0
-                ? Promise.race([
-                    workflowPromise,
-                    new Promise((_, reject) => {
-                        setTimeout(() => reject(new Error('V3_SAAS_SOFT_TIMEOUT')), DEFAULT_V3_AGENT_SOFT_TIMEOUT_MS);
-                    }),
-                ])
-                : workflowPromise);
+            const response = await workflowPromise;
             if (spinner) {
                 spinner.stop();
             }
@@ -1773,9 +1813,9 @@ class ChatCommand {
         }
         catch (error) {
             watcher?.stop();
-            if (rescueEligible && !this.api.hasAgentWorkspaceOutput(workspaceContext)) {
-                const rescued = await this.tryCommandLevelSaaSRescue(executionPrompt, prompt, workspaceContext, routingPolicy, spinner, error);
-                if (rescued) {
+            if (!this.api.hasAgentWorkspaceOutput(workspaceContext)) {
+                const recovered = await this.tryRecoverV3ServiceAndRetry(executionPrompt, prompt, workspaceContext, routingPolicy, spinner, error);
+                if (recovered) {
                     return true;
                 }
             }
@@ -1811,60 +1851,67 @@ class ChatCommand {
             return true;
         }
     }
-    isSaaSRescuePrompt(prompt) {
-        return /(saas|dashboard|analytics|billing|team management|activity feed|login screen)/i.test(prompt);
-    }
-    async tryCommandLevelSaaSRescue(executionPrompt, rawPrompt, workspaceContext, routingPolicy, spinner, error) {
-        const apiAny = this.api;
-        if (typeof apiAny.materializeEmergencySaaSWorkspace !== 'function') {
+    async tryRecoverV3ServiceAndRetry(executionPrompt, rawPrompt, workspaceContext, routingPolicy, spinner, error) {
+        const recovery = await this.api.attemptV3ServiceRecovery((error && error.message) || '');
+        if (!recovery.recovered) {
             return false;
         }
-        const appName = apiAny.materializeEmergencySaaSWorkspace(executionPrompt, workspaceContext);
-        if (!appName) {
-            return false;
-        }
-        if (typeof apiAny.ensureAgentFrontendPolish === 'function') {
-            await apiAny.ensureAgentFrontendPolish(executionPrompt, workspaceContext);
-        }
-        const previewGate = await this.api.runTemplateServicePreviewGate(executionPrompt, {
-            ...workspaceContext,
-            rawPrompt,
-        });
-        if (spinner) {
+        if (spinner && spinner.isSpinning) {
             spinner.stop();
         }
-        const rescueMessage = `Recovered a local SaaS workspace scaffold for ${appName} after the V3 workflow stalled without writing files.`;
-        if (this.jsonOutput) {
-            console.log(JSON.stringify({
-                success: true,
-                mode: 'agent',
-                model: routingPolicy.selectedModel,
-                routingPolicy,
-                taskId: null,
-                contextId: null,
-                partial: true,
-                content: rescueMessage,
-                metadata: {
-                    source: 'cli-saas-rescue',
-                    previewGate,
-                    rescueReason: error.message,
-                },
-            }, null, 2));
+        if (!this.jsonOutput) {
+            console.log(chalk_1.default.yellow(`V3 recovery: ${recovery.message} Retrying once...`));
         }
-        else {
-            console.log(chalk_1.default.gray(`Agent routing: ${routingPolicy.cloudSelected ? 'Vigthoria Cloud' : 'V3 Agent'}`));
-            console.log(rescueMessage);
-            if (previewGate.required) {
-                if (previewGate.passed) {
-                    console.log(chalk_1.default.gray(`Template Service preview gate: passed via ${previewGate.backendUrl || 'unknown backend'}`));
-                }
-                else {
-                    console.log(chalk_1.default.yellow(`Template Service preview gate: failed${previewGate.error ? ` - ${previewGate.error}` : ''}`));
-                }
+        this.v3IterationCount = 0;
+        this.v3ToolCallCount = 0;
+        this.v3LastActivity = Date.now();
+        this.v3StreamingStarted = false;
+        try {
+            const retryResponse = await this.api.runV3AgentWorkflow(executionPrompt, {
+                workspace: { path: this.currentProjectPath },
+                ...workspaceContext,
+                executionSurface: 'cli',
+                clientSurface: 'cli',
+                localMachineCapable: true,
+                agentTimeoutMs: DEFAULT_V3_AGENT_TIMEOUT_MS,
+                agentIdleTimeoutMs: DEFAULT_V3_AGENT_IDLE_TIMEOUT_MS,
+                model: routingPolicy.selectedModel,
+                requestedModel: this.currentModel,
+                agentExecutionPolicy: routingPolicy,
+                legacyFallbackAllowed: this.isLegacyAgentFallbackAllowed(),
+                rawPrompt,
+                history: this.getMessagesForModel(),
+                onStreamEvent: spinner ? (event) => this.updateV3AgentSpinner(spinner, event) : undefined,
+            });
+            if (spinner && spinner.isSpinning) {
+                spinner.stop();
+            }
+            if (this.v3StreamingStarted) {
+                process.stdout.write('\n');
+            }
+            if (this.jsonOutput) {
+                console.log(JSON.stringify({
+                    success: true,
+                    mode: 'agent',
+                    model: routingPolicy.selectedModel,
+                    routingPolicy,
+                    taskId: retryResponse.taskId || null,
+                    contextId: retryResponse.contextId || null,
+                    partial: retryResponse.partial === true,
+                    content: retryResponse.content || 'V3 agent workflow completed after recovery.',
+                    metadata: { ...(retryResponse.metadata || {}), recoveryAttempted: true },
+                }, null, 2));
+            }
+            else if (!this.v3StreamingStarted && retryResponse.content) {
+                console.log(chalk_1.default.gray(`Agent routing: ${routingPolicy.cloudSelected ? 'Vigthoria Cloud' : 'V3 Agent'}`));
+                console.log(retryResponse.content);
             }
+            this.messages.push({ role: 'assistant', content: retryResponse.content || 'V3 agent workflow completed after recovery.' });
+            return true;
+        }
+        catch {
+            return false;
         }
-        this.messages.push({ role: 'assistant', content: rescueMessage });
-        return true;
     }
     async startInteractiveChat() {
         const chatTitle = this.operatorMode

package/dist/index.js

@@ -77,6 +77,9 @@ const logger_js_1 = require("./utils/logger.js");
 const chalk_1 = __importDefault(require("chalk"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const crypto_1 = require("crypto");
+const axios_1 = __importDefault(require("axios"));
 function getInvokedBinaryName() {
     const executable = process.argv[1] || 'vigthoria';
     return path.basename(executable, path.extname(executable)).toLowerCase();
@@ -107,6 +110,7 @@ function getVersion() {
     return '1.6.27';
 }
 const VERSION = getVersion();
+const VIGTHORIA_DEFAULT_MANIFEST_URL = process.env.VIGTHORIA_UPDATE_MANIFEST_URL || "https://coder.vigthoria.io/releases/manifest.json";
 /**
  * Compare semantic versions properly
  * Returns: -1 if v1 < v2, 0 if equal, 1 if v1 > v2
@@ -124,6 +128,40 @@ function compareVersions(v1, v2) {
     }
     return 0;
 }
+function resolveManifestEntry(manifest, channel) {
+    const normalized = String(channel || 'stable').trim() || 'stable';
+    if (manifest.channels && manifest.channels[normalized]) {
+        return manifest.channels[normalized];
+    }
+    const direct = manifest[normalized];
+    if (direct && typeof direct === 'object') {
+        return direct;
+    }
+    if (normalized === 'stable') {
+        const rootVersion = typeof manifest.version === 'string' ? manifest.version : '';
+        const rootUrl = typeof manifest.url === 'string' ? manifest.url : '';
+        const rootSha = typeof manifest.sha256 === 'string' ? manifest.sha256 : undefined;
+        if (rootVersion && rootUrl) {
+            return { version: rootVersion, url: rootUrl, sha256: rootSha };
+        }
+    }
+    return null;
+}
+async function downloadFile(url, targetPath) {
+    const response = await axios_1.default.get(url, {
+        responseType: 'arraybuffer',
+        timeout: 20000,
+        maxRedirects: 5,
+        validateStatus: (status) => status >= 200 && status < 300,
+    });
+    fs.writeFileSync(targetPath, Buffer.from(response.data));
+}
+function sha256File(filePath) {
+    const hash = (0, crypto_1.createHash)('sha256');
+    const data = fs.readFileSync(filePath);
+    hash.update(data);
+    return hash.digest('hex');
+}
 // Check for updates silently on startup (non-blocking)
 async function checkForUpdatesQuietly() {
     try {
@@ -821,11 +859,111 @@ Examples:
     program
         .command('update')
         .alias('upgrade')
-        .description('Check for updates and upgrade Vigthoria CLI')
+        .description('Check for updates and upgrade Vigthoria CLI. Default manifest: https://coder.vigthoria.io/releases/manifest.json')
         .option('-c, --check', 'Only check for updates, don\'t install')
+        .option('-f, --from <target>', 'Install update from npm spec, local .tgz path, or URL')
+        .option('-m, --manifest <url>', 'Update manifest URL for server-driven releases')
+        .option('--channel <name>', 'Release channel to use from manifest (default: stable)', 'stable')
+        .option('--allow-downgrade', 'Allow installing an older version from custom update source')
         .action(async (options) => {
-        const { execSync } = await import('child_process');
-        console.log(chalk_1.default.cyan('🔍 Checking for updates...'));
+        const { execSync, execFileSync } = await import('child_process');
+        const updateTarget = typeof options.from === 'string' ? options.from.trim() : '';
+        const manifestUrl = typeof options.manifest === 'string' ? options.manifest.trim() : VIGTHORIA_DEFAULT_MANIFEST_URL.trim();
+        const channel = typeof options.channel === 'string' ? options.channel.trim() : 'stable';
+        const allowDowngrade = !!options.allowDowngrade;
+        if (updateTarget) {
+            try {
+                if (options.check) {
+                    console.log(chalk_1.default.cyan(`Update source configured: ${updateTarget}`));
+                    console.log(chalk_1.default.gray('Run `vigthoria update --from <target>` to install from this source'));
+                    return;
+                }
+                console.log(chalk_1.default.cyan(`Installing update from ${updateTarget}...`));
+                execFileSync('npm', ['install', '-g', updateTarget], {
+                    stdio: 'inherit',
+                    windowsHide: true,
+                });
+                console.log(chalk_1.default.green('Update installed successfully'));
+                console.log(chalk_1.default.gray('Please restart the CLI to use the new version'));
+                return;
+            }
+            catch (error) {
+                console.error(chalk_1.default.red('Failed to install update from target:'), error.message);
+                console.log(chalk_1.default.gray(`Try manually: npm install -g ${updateTarget}`));
+                return;
+            }
+        }
+        if (manifestUrl) {
+            try {
+                console.log(chalk_1.default.cyan(`Checking manifest channel ${channel}...`));
+                const response = await axios_1.default.get(manifestUrl, {
+                    timeout: 10000,
+                    maxRedirects: 5,
+                    validateStatus: (status) => status >= 200 && status < 300,
+                });
+                const entry = resolveManifestEntry(response.data || {}, channel);
+                if (!entry || !entry.version || !entry.url) {
+                    console.error(chalk_1.default.red(`Manifest missing valid release entry for channel: ${channel}`));
+                    console.log(chalk_1.default.gray('Expected: channels.<channel>.version and channels.<channel>.url'));
+                    return;
+                }
+                const currentVersion = VERSION;
+                const comparison = compareVersions(entry.version, currentVersion);
+                if (!allowDowngrade && comparison <= 0) {
+                    console.log(chalk_1.default.green(`You are running the latest version for channel ${channel} (${currentVersion})`));
+                    return;
+                }
+                console.log(chalk_1.default.yellow(`Update available from manifest: ${currentVersion} -> ${entry.version} (${channel})`));
+                if (entry.notes) {
+                    console.log(chalk_1.default.gray(`   ${entry.notes}`));
+                }
+                if (options.check) {
+                    console.log(chalk_1.default.gray(`Install with: vigthoria update --manifest ${manifestUrl} --channel ${channel}`));
+                    return;
+                }
+                const tmpFile = path.join(os.tmpdir(), `vigthoria-update-${Date.now()}.tgz`);
+                try {
+                    console.log(chalk_1.default.cyan('Downloading release package...'));
+                    await downloadFile(entry.url, tmpFile);
+                    if (entry.sha256) {
+                        const expected = entry.sha256.toLowerCase();
+                        const actual = sha256File(tmpFile).toLowerCase();
+                        if (actual !== expected) {
+                            console.error(chalk_1.default.red('Release checksum verification failed'));
+                            console.error(chalk_1.default.red(`Expected: ${expected}`));
+                            console.error(chalk_1.default.red(`Actual:   ${actual}`));
+                            return;
+                        }
+                        console.log(chalk_1.default.green('Checksum verification passed'));
+                    }
+                    else {
+                        console.log(chalk_1.default.yellow('Manifest entry has no sha256; install proceeded without checksum verification'));
+                    }
+                    console.log(chalk_1.default.cyan('Installing update...'));
+                    execFileSync('npm', ['install', '-g', tmpFile], {
+                        stdio: 'inherit',
+                        windowsHide: true,
+                    });
+                    console.log(chalk_1.default.green(`Updated to version ${entry.version}`));
+                    console.log(chalk_1.default.gray('Please restart the CLI to use the new version'));
+                    return;
+                }
+                finally {
+                    if (fs.existsSync(tmpFile)) {
+                        try {
+                            fs.unlinkSync(tmpFile);
+                        }
+                        catch { }
+                    }
+                }
+            }
+            catch (error) {
+                console.error(chalk_1.default.red('Failed to process manifest update:'), error.message);
+                console.log(chalk_1.default.gray('You can still update via npm: npm install -g vigthoria-cli@latest'));
+                return;
+            }
+        }
+        console.log(chalk_1.default.cyan('Checking for updates...'));
         try {
             // Get latest version from npm - cross-platform
             const latestVersion = execSync('npm view vigthoria-cli version', {
@@ -837,21 +975,21 @@ Examples:
             // Use semantic version comparison (1.6.0 > 1.5.9)
             const comparison = compareVersions(latestVersion, currentVersion);
             if (comparison <= 0) {
-                console.log(chalk_1.default.green(`✅ You are running the latest version (${currentVersion})`));
+                console.log(chalk_1.default.green(`You are running the latest version (${currentVersion})`));
                 return;
             }
-            console.log(chalk_1.default.yellow(`📦 Update available: ${currentVersion} → ${latestVersion}`));
+            console.log(chalk_1.default.yellow(`Update available: ${currentVersion} -> ${latestVersion}`));
             if (options.check) {
                 console.log(chalk_1.default.gray('Run `vigthoria update` to install the update'));
                 return;
             }
-            console.log(chalk_1.default.cyan('📥 Installing update...'));
+            console.log(chalk_1.default.cyan('Installing update...'));
             execSync('npm install -g vigthoria-cli@latest', { stdio: 'inherit' });
-            console.log(chalk_1.default.green(`✅ Updated to version ${latestVersion}`));
+            console.log(chalk_1.default.green(`Updated to version ${latestVersion}`));
             console.log(chalk_1.default.gray('Please restart the CLI to use the new version'));
         }
         catch (error) {
-            console.error(chalk_1.default.red('❌ Failed to check for updates:'), error.message);
+            console.error(chalk_1.default.red('Failed to check for updates:'), error.message);
             console.log(chalk_1.default.gray('Try manually: npm install -g vigthoria-cli@latest'));
         }
     });

package/dist/utils/api.d.ts

@@ -19,6 +19,9 @@ export declare class CLIError extends Error {
 export declare function classifyError(error: unknown, fallbackCategory?: CLIErrorCategory): CLIError;
 /** Format a CLIError for user-facing display. */
 export declare function formatCLIError(err: CLIError): string;
+export declare function sanitizeUserFacingErrorText(input: string): string;
+export declare function isServerRuntime(): boolean;
+export declare function describeUpstreamStatus(status: number): string;
 export interface ChatMessage {
     role: 'user' | 'assistant' | 'system';
     content: string;
@@ -39,8 +42,8 @@ export interface V3AgentWorkflowResponse {
     contextId?: string | null;
     backendUrl: string;
     partial?: boolean;
-    changedFiles?: Record<string, string>;
     metadata?: Record<string, unknown>;
+    changedFiles?: Record<string, string>;
 }
 export interface FrontendPreviewGateResult {
     required: boolean;
@@ -186,9 +189,6 @@ export interface VigthoriUser {
         adminAccess: boolean;
     };
 }
-export declare function sanitizeUserFacingErrorText(input: string): string;
-export declare function isServerRuntime(): boolean;
-export declare function describeUpstreamStatus(status: number): string;
 export declare class APIClient {
     private client;
     private modelRouterClient;
@@ -197,18 +197,12 @@ export declare class APIClient {
     private logger;
     private ws;
     private vigFlowTokens;
-    private _httpsAgent;
     constructor(config: Config, logger: Logger);
-    /**
-     * Destroy keep-alive sockets so the Node.js event loop can drain
-     * naturally.  Call this before exiting commands that run HTTP probes
-     * (e.g. `status`) to avoid the libuv UV_HANDLE_CLOSING assertion
-     * on Windows / Node 25+.
-     */
     destroy(): void;
     private getSelfHostedModelsApiUrl;
     login(email: string, password: string): Promise<boolean>;
     loginWithToken(token: string): Promise<boolean>;
+    private decodeJwtPayload;
     private extractUserProfile;
     private refreshToken;
     getSubscriptionStatus(): Promise<void>;
@@ -292,7 +286,6 @@ export declare class APIClient {
     private compactV3Context;
     buildMinimalV3AgentContext(context?: Record<string, any>): string;
     private extractEmergencyAppName;
-    private materializeEmergencySaaSWorkspace;
     private ensureExecutionContext;
     bindExecutionContext(context?: Record<string, any>): Promise<Record<string, any>>;
     private resolveAgentTargetPath;
@@ -363,11 +356,6 @@ export declare class APIClient {
      * Ensure code has balanced curly braces by appending missing closing braces.
      */
     private ensureBalancedBraces;
-    /**
-     * Quick JS/TS syntax validation using Node's built-in parser.
-     * Returns true if the code parses without errors.
-     */
-    private validateJsSyntax;
     /**
      * Extract the first complete function/class from code.
      * Used as last-resort when the model keeps over-producing.
@@ -455,6 +443,14 @@ export declare class APIClient {
     private getCoderHealth;
     private getModelsHealth;
     private getSelfHostedHealth;
+    attemptV3ServiceRecovery(reason?: string, options?: {
+        attempts?: number;
+        delayMs?: number;
+    }): Promise<{
+        recovered: boolean;
+        message: string;
+        endpoint?: string;
+    }>;
     private getV3AgentHealth;
     private getHyperLoopHealth;
     private getRepoMemoryHealth;