vigthoria-cli 1.10.1 → 1.10.36

package/dist/commands/auth.d.ts

@@ -2,6 +2,7 @@ import { Command } from 'commander';
 export interface AuthConfig {
     apiUrl: string;
     token?: string;
+    v3ServiceKey?: string;
     user?: {
         id?: string;
         email?: string;

package/dist/commands/auth.js

@@ -7,7 +7,7 @@ import { Config } from '../utils/config.js';
 const DEFAULT_API_URL = 'https://coder.vigthoria.io';
 const CONFIG_DIR = path.join(homedir(), '.vigthoria');
 const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
-const KNOWN_AUTH_BASE_URLS = ['https://coder.vigthoria.io', 'https://api.vigthoria.io'];
+const KNOWN_AUTH_BASE_URLS = ['https://coder.vigthoria.io'];
 class HttpError extends Error {
     status;
     constructor(status, message) {
@@ -62,6 +62,9 @@ function syncSharedConfig(config) {
         if (config.user?.email) {
             shared.set('email', String(config.user.email));
         }
+        if (config.v3ServiceKey) {
+            shared.set('v3ServiceKey', config.v3ServiceKey);
+        }
     }
     catch {
         // Keep legacy auth flow working even if shared config write fails.
@@ -74,6 +77,7 @@ function clearSharedConfigAuth() {
         shared.set('refreshToken', null);
         shared.set('userId', null);
         shared.set('email', null);
+        shared.set('v3ServiceKey', null);
     }
     catch {
         // Ignore shared config clear failures during logout.
@@ -125,6 +129,7 @@ export function loadAuthConfig() {
         return {
             apiUrl: trimTrailingSlash(parsed.apiUrl || getApiUrl()),
             token: parsed.token || parsed.authToken,
+            v3ServiceKey: typeof parsed.v3ServiceKey === 'string' ? parsed.v3ServiceKey : undefined,
             user: parsed.user,
         };
     }
@@ -203,6 +208,23 @@ async function requestJson(url, init) {
     }
     return body;
 }
+async function fetchV3ServiceKey(apiBase, token) {
+    try {
+        const endpoint = `${trimTrailingSlash(apiBase)}/api/cli/v3-service-key`;
+        const result = await requestJson(endpoint, {
+            method: 'GET',
+            headers: { authorization: `Bearer ${token}` },
+        });
+        const key = result?.v3ServiceKey;
+        if (typeof key === 'string' && key.trim()) {
+            return key.trim();
+        }
+    }
+    catch {
+        // Non-fatal during login; V3 preflight can still fetch later via API utility.
+    }
+    return undefined;
+}
 async function ask(question, hidden = false) {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     if (!hidden) {
@@ -214,18 +236,20 @@ async function ask(question, hidden = false) {
         }
     }
     const output = process.stdout;
+    // Write the label directly so masking doesn't hide it
+    output.write(question);
     const mutableRl = rl;
     const originalWrite = mutableRl._writeToOutput;
     mutableRl._writeToOutput = function writeMasked(value) {
         if (value.includes('\n') || value.includes('\r')) {
             output.write(value);
         }
-        else {
+        else if (value.length > 0) {
             output.write('*');
         }
     };
     try {
-        return await new Promise((resolve) => rl.question(question, resolve));
+        return await new Promise((resolve) => rl.question('', resolve));
     }
     finally {
         if (originalWrite) {
@@ -271,10 +295,13 @@ export async function login(email, password) {
                         failures.push(`${endpoint} -> success without token`);
                         continue;
                     }
+                    const normalizedBase = trimTrailingSlash(base);
+                    const v3ServiceKey = await fetchV3ServiceKey(normalizedBase, token);
                     const config = {
-                        apiUrl: trimTrailingSlash(base),
+                        apiUrl: normalizedBase,
                         token,
                         user: extractAuthUser(result, resolvedEmail),
+                        ...(v3ServiceKey ? { v3ServiceKey } : {}),
                         success: true,
                     };
                     saveAuthConfig(config);
@@ -287,11 +314,7 @@ export async function login(email, password) {
                 }
             }
         }
-        throw new Error([
-            'Login failed on all known auth endpoints.',
-            `Tried: ${attempted.join(', ')}`,
-            `Last errors: ${failures.slice(-4).join(' | ')}`,
-        ].join(' '));
+        throw new Error('Invalid email or password. Please check your credentials and try again.');
     }
     catch (error) {
         const message = humanMessage(error);
@@ -399,6 +422,10 @@ export async function handleLogin(options = {}) {
                 token: options.token,
                 success: true,
             };
+            const v3ServiceKey = await fetchV3ServiceKey(config.apiUrl, options.token);
+            if (v3ServiceKey) {
+                config.v3ServiceKey = v3ServiceKey;
+            }
             saveAuthConfig(config);
             console.log(chalk.green('Logged in successfully with API token.'));
             process.exitCode = 0;
@@ -413,7 +440,7 @@ export async function handleLogin(options = {}) {
             email = (await ask('Email: ')).trim();
         }
         if (!password) {
-            password = await ask('Password: ', true);
+            password = (await ask('Password: ', true)).trim();
         }
         if (!email || !password) {
             throw new Error('Email and password are required. Use --email and --password, or run vigthoria login interactively.');
@@ -423,6 +450,36 @@ export async function handleLogin(options = {}) {
         if (config.user?.email) {
             console.log(`Account: ${config.user.email}`);
         }
+        // Fetch and display subscription tier + role
+        try {
+            const subResponse = await fetch(`${config.apiUrl}/api/user/subscription`, {
+                headers: { Authorization: `Bearer ${config.token}`, Cookie: `vigthoria-auth-token=${config.token}` },
+                signal: AbortSignal.timeout(5000),
+            });
+            if (subResponse.ok) {
+                const sub = await subResponse.json();
+                const subRecord = (sub.subscription && typeof sub.subscription === 'object') ? sub.subscription : {};
+                const userRecord = (sub.user && typeof sub.user === 'object') ? sub.user : {};
+                const plan = String(sub.plan || subRecord.plan || userRecord.plan || userRecord.subscription_plan || '').trim();
+                const role = String(sub.role || subRecord.role || userRecord.role || userRecord.user_role || '').trim();
+                if (plan) {
+                    console.log(`Plan:  ${plan.toUpperCase()}`);
+                }
+                if (role) {
+                    console.log(`Role:  ${role}`);
+                }
+            }
+        }
+        catch { /* non-fatal — login already succeeded */ }
+        try {
+            const sharedConfig = new Config();
+            await sharedConfig.refreshHubModelPreferences();
+            const hubPrefs = sharedConfig.get('hubModelPrefs');
+            if (hubPrefs?.balance !== undefined) {
+                console.log(`Cloud credits: ${hubPrefs.balance}`);
+            }
+        }
+        catch { /* non-fatal */ }
         console.log(`API: ${config.apiUrl}`);
         process.exitCode = 0;
         return config;
@@ -446,27 +503,52 @@ export async function handleLogout(_options) {
 }
 export async function statusAction() {
     try {
-        const config = loadAuthConfig();
-        if (!config.token) {
+        const legacyConfig = loadAuthConfig();
+        const sharedConfig = new Config();
+        const sharedApiUrl = String(sharedConfig.get('apiUrl') || '').trim();
+        const sharedToken = String(sharedConfig.get('authToken') || '').trim();
+        const effectiveApiUrl = trimTrailingSlash(sharedApiUrl || legacyConfig.apiUrl || getApiUrl());
+        const effectiveToken = sharedToken || legacyConfig.token || '';
+        if (!effectiveToken) {
             console.log(chalk.yellow('Not logged in.'));
             process.exitCode = 0;
             return;
         }
-        let user = config.user;
+        const authProbeHeaders = {
+            Authorization: `Bearer ${effectiveToken}`,
+            Cookie: `vigthoria-auth-token=${effectiveToken}`,
+        };
+        let authLooksValid = true;
+        try {
+            const authProbe = await fetch(`${effectiveApiUrl}/api/user/subscription`, { headers: authProbeHeaders, signal: AbortSignal.timeout(6000) });
+            if (authProbe.status === 401 || authProbe.status === 403) {
+                authLooksValid = false;
+            }
+        }
+        catch {
+            // Network failures should not force logout status.
+        }
+        if (!authLooksValid) {
+            console.log(chalk.yellow('Not logged in. Session expired or invalid.'));
+            console.log(chalk.gray('Run: vigthoria login'));
+            process.exitCode = 1;
+            return;
+        }
+        let user = legacyConfig.user;
         try {
             user = await whoami();
         }
         catch {
             // Keep local status available even if remote whoami endpoint is down.
         }
-        const sharedConfig = new Config();
         let overallStatus = 'Unknown';
         let coderStatus = 'Unknown';
         let modelsStatus = 'Unknown';
+        const modelsApiBase = trimTrailingSlash(String(sharedConfig.get('modelsApiUrl') || 'https://api.vigthoria.io'));
         try {
             const [coderResponse, modelsResponse] = await Promise.all([
-                fetch(`${trimTrailingSlash(config.apiUrl)}/api/health`),
-                fetch('https://api.vigthoria.io/health'),
+                fetch(`${effectiveApiUrl}/api/health`, { signal: AbortSignal.timeout(8000) }),
+                fetch(`${modelsApiBase}/health`, { signal: AbortSignal.timeout(8000) }),
             ]);
             const coderJson = await coderResponse.json().catch(() => ({}));
             const modelsJson = await modelsResponse.json().catch(() => ({}));
@@ -491,7 +573,7 @@ export async function statusAction() {
         console.log(`Overall: ${overallStatus}`);
         console.log(`Coder API: ${coderStatus}`);
         console.log(`Models API: ${modelsStatus}`);
-        console.log(`API: ${config.apiUrl}`);
+        console.log(`API: ${effectiveApiUrl}`);
         process.exitCode = 0;
     }
     catch (error) {

package/dist/commands/chat.d.ts

@@ -16,6 +16,7 @@ interface ChatOptions {
     prompt?: string;
     json?: boolean;
     bridge?: string;
+    grant?: boolean;
 }
 export declare class ChatCommand {
     private config;
@@ -34,6 +35,7 @@ export declare class ChatCommand {
     private currentModel;
     private modelExplicitlySelected;
     private autoApprove;
+    private personaOverride;
     private agentToolEvidence;
     private operatorMode;
     private workflowTarget;
@@ -59,12 +61,26 @@ export declare class ChatCommand {
     private isLegacyAgentFallbackAllowed;
     private resolveAgentExecutionPolicy;
     private getMessagesForModel;
+    private normalizeClientV3ToolPath;
+    private resolveClientV3ToolPath;
+    private normalizeClientV3ToolArgs;
+    private executeClientV3Tool;
+    private getActivePersonaMode;
+    private buildActivePersonaOverlay;
     private isDiagnosticPrompt;
     /**
      * Returns true when the prompt is a simple lookup / analysis / read-only
      * question — these should use analysis_only workflow, not full_autonomy.
      */
     private isAnalysisLookupPrompt;
+    private isImplementationPrompt;
+    private getWindowsPromptPathRoots;
+    private findPromptDirectoryByName;
+    private extractExplicitLocalPath;
+    private isUnscopedPromptPathOverrideAllowed;
+    private isPathWithinRoot;
+    private getPromptPathAllowedRoots;
+    private resolvePromptWorkspacePath;
     private isBrowserTaskPrompt;
     /**
      * Returns true when a prompt can be answered directly without the full
@@ -81,6 +97,7 @@ export declare class ChatCommand {
      */
     private isRepoGroundedPrompt;
     private inferAgentTaskType;
+    private bindPromptWorkspace;
     private buildTaskShapingInstructions;
     private buildExecutionPrompt;
     private isProjectBrainRuntimeDisabled;
@@ -91,15 +108,26 @@ export declare class ChatCommand {
     private v3ToolCallCount;
     private v3LastActivity;
     private v3StreamingStarted;
+    private v3StreamedTextBuffer;
+    private v3LiveToolEvidence;
+    private v3PendingToolCalls;
     /**
      * Strip server-internal path prefixes from tool output strings.
      * Prevents exposing paths like /var/www/V3-Code-Agent/... to end users.
      */
     private sanitizeServerPath;
+    private stripHiddenThoughtBlocks;
     private describeV3AgentTool;
     private isRawV3StreamPayload;
     private consumeV3StreamPayload;
     private writeV3StreamText;
+    private isGenericV3AgentContent;
+    private hasAlreadyStreamedV3Content;
+    private isThinV3Summary;
+    private shouldPrintV3FinalContent;
+    private rememberV3ToolEvidence;
+    private buildUserFacingV3RunReport;
+    private printV3UserReport;
     private updateV3AgentSpinner;
     private updateOperatorSpinner;
     constructor(config: Config, logger: Logger);
@@ -107,6 +135,7 @@ export declare class ChatCommand {
     /** Handle an inbound admin command from the Commando Bridge. */
     private handleAdminCommand;
     private ensureProjectWorkspace;
+    private shouldStartWorkspaceWatcher;
     private resolveProjectPath;
     private shouldUseManagedWorkspace;
     private getManagedWorkspaceRoot;
@@ -134,7 +163,11 @@ export declare class ChatCommand {
     private runOperatorDirectAnswer;
     private runSimplePrompt;
     private runAgentTurn;
+    private localAgentIterationCount;
+    private buildLocalAgentChatOptions;
+    private printChatModelPreflight;
     private runLocalAgentLoop;
+    private primeBypassedTargetFileContext;
     private tryDirectSingleFileFlow;
     private isConfirmationFollowUp;
     private getPreviousActionablePrompt;
@@ -210,6 +243,7 @@ export declare class ChatCommand {
     private buildLocalAnalysisFallback;
     private tryDeterministicSingleFileRewrite;
     private extractExactTextRequirement;
+    private tryLocalToolFallback;
     private executeToolCalls;
     private formatToolResult;
     private truncateText;