vigthoria-cli 1.6.57 → 1.6.59

package/dist/commands/auth.d.ts

@@ -12,8 +12,7 @@ export declare class AuthCommand {
     private api;
     constructor(config: Config, logger: Logger);
     login(options: LoginOptions): Promise<void>;
-    private loginWithCredentials;
-    private loginWithTokenPrompt;
+    private doCredentialLogin;
     private loginWithToken;
     private loginWithBrowser;
     logout(): Promise<void>;

package/dist/commands/auth.js

@@ -29,7 +29,11 @@ class AuthCommand {
         console.log();
         console.log(chalk_1.default.cyan(`${logger_js_1.CH.hDouble.repeat(3)} Vigthoria Login ${logger_js_1.CH.hDouble.repeat(3)}`));
         console.log();
-        // Prompt for credentials
+        // Collect ALL interactive input in a single inquirer.prompt() call.
+        // inquirer 9.x creates and destroys a readline interface per prompt()
+        // call; on Node 20 TTY the second readline on the same process.stdin
+        // throws ERR_USE_AFTER_CLOSE.  Using `when` conditionals keeps one
+        // readline alive for the entire login flow.
         const answers = await inquirer_1.default.prompt([
             {
                 type: 'list',
@@ -41,25 +45,11 @@ class AuthCommand {
                     { name: 'Browser Login', value: 'browser' },
                 ],
             },
-        ]);
-        switch (answers.method) {
-            case 'credentials':
-                await this.loginWithCredentials();
-                break;
-            case 'token':
-                await this.loginWithTokenPrompt();
-                break;
-            case 'browser':
-                await this.loginWithBrowser();
-                break;
-        }
-    }
-    async loginWithCredentials() {
-        const credentials = await inquirer_1.default.prompt([
             {
                 type: 'input',
                 name: 'email',
                 message: 'Email:',
+                when: (ans) => ans.method === 'credentials',
                 validate: (input) => {
                     const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
                     return emailRegex.test(input) || 'Please enter a valid email';
@@ -70,11 +60,33 @@ class AuthCommand {
                 name: 'password',
                 message: 'Password:',
                 mask: '*',
+                when: (ans) => ans.method === 'credentials',
                 validate: (input) => input.length >= 6 || 'Password must be at least 6 characters',
             },
+            {
+                type: 'password',
+                name: 'token',
+                message: 'API Token:',
+                mask: '*',
+                when: (ans) => ans.method === 'token',
+                validate: (input) => input.length > 0 || 'Please enter your API token',
+            },
         ]);
+        switch (answers.method) {
+            case 'credentials':
+                await this.doCredentialLogin(answers.email, answers.password);
+                break;
+            case 'token':
+                await this.loginWithToken(answers.token);
+                break;
+            case 'browser':
+                await this.loginWithBrowser();
+                break;
+        }
+    }
+    async doCredentialLogin(email, password) {
         const spinner = (0, logger_js_1.createSpinner)('Logging in...').start();
-        const success = await this.api.login(credentials.email, credentials.password);
+        const success = await this.api.login(email, password);
         spinner.stop();
         if (success) {
             this.printLoginSuccess();
@@ -83,18 +95,6 @@ class AuthCommand {
             this.logger.error('Login failed. Please check your credentials.');
         }
     }
-    async loginWithTokenPrompt() {
-        const { token } = await inquirer_1.default.prompt([
-            {
-                type: 'password',
-                name: 'token',
-                message: 'API Token:',
-                mask: '*',
-                validate: (input) => input.length > 0 || 'Please enter your API token',
-            },
-        ]);
-        await this.loginWithToken(token);
-    }
     async loginWithToken(token) {
         const spinner = (0, logger_js_1.createSpinner)('Validating token...').start();
         const success = await this.api.loginWithToken(token);

package/dist/commands/chat.d.ts

@@ -74,6 +74,7 @@ export declare class ChatCommand {
     private v3IterationCount;
     private v3ToolCallCount;
     private v3LastActivity;
+    private v3StreamingStarted;
     private describeV3AgentTool;
     private updateV3AgentSpinner;
     private updateOperatorSpinner;

package/dist/commands/chat.js

@@ -298,6 +298,7 @@ class ChatCommand {
     v3IterationCount = 0;
     v3ToolCallCount = 0;
     v3LastActivity = Date.now();
+    v3StreamingStarted = false;
     describeV3AgentTool(toolName) {
         const normalized = String(toolName || '').toLowerCase();
         if (/read|grep|search|list|find|glob/.test(normalized)) {
@@ -324,6 +325,9 @@ class ChatCommand {
             const toolDesc = this.describeV3AgentTool(event.tool || event.name || event.tool_name);
             const toolTarget = event.arguments?.path || event.arguments?.file_path || event.arguments?.pattern || '';
             const shortTarget = toolTarget ? ` → ${String(toolTarget).split('/').slice(-2).join('/')}` : '';
+            if (this.v3StreamingStarted && !spinner.isSpinning) {
+                spinner.start();
+            }
             spinner.text = chalk_1.default.cyan(`[${this.v3IterationCount}/${this.v3ToolCallCount}] `) + `${toolDesc}${shortTarget}`;
             return;
         }
@@ -331,6 +335,9 @@ class ChatCommand {
             const success = event.success !== false;
             const toolName = event.name || event.tool || '';
             const indicator = success ? chalk_1.default.green('✓') : chalk_1.default.red('✗');
+            if (this.v3StreamingStarted && !spinner.isSpinning) {
+                spinner.start();
+            }
             spinner.text = `${indicator} ${toolName} complete — next step...`;
             return;
         }
@@ -339,12 +346,32 @@ class ChatCommand {
             const iterText = event.content || '';
             const iterMatch = iterText.match(/Iteration (\d+)/i);
             const iterNum = iterMatch ? iterMatch[1] : String(this.v3IterationCount);
+            if (this.v3StreamingStarted && !spinner.isSpinning) {
+                spinner.start();
+            }
             spinner.text = chalk_1.default.cyan(`[Iteration ${iterNum}] `) + 'Analyzing...';
             return;
         }
-        if (event.type === 'message') {
-            const preview = String(event.content || '').slice(0, 80).replace(/\n/g, ' ');
-            spinner.text = chalk_1.default.cyan('[Response] ') + (preview || 'Writing response...');
+        if (event.type === 'message' || event.type === 'assistant' || event.type === 'text' || event.type === 'content_block_delta') {
+            const text = event.type === 'content_block_delta'
+                ? (event.delta?.text || '')
+                : (event.content || '');
+            if (text) {
+                if (!this.v3StreamingStarted) {
+                    this.v3StreamingStarted = true;
+                    spinner.stop();
+                    if (!this.directPromptMode) {
+                        console.log();
+                    }
+                }
+                else {
+                    spinner.stop();
+                }
+                process.stdout.write(text);
+            }
+            else {
+                spinner.text = chalk_1.default.cyan('[Response] ') + 'Writing response...';
+            }
             return;
         }
         if (event.type === 'complete') {
@@ -828,13 +855,19 @@ class ChatCommand {
             await this.runOperatorDirectAnswer(prompt);
             return;
         }
-        // ── Repo-grounded operator path: use the agent loop with tools ──
+        // ── Repo-grounded operator path: try V3 agent first, then fall back ──
         // Prompts that reference files, code symbols, or analysis verbs need
         // tool access to read actual file contents.  Route these through the
-        // local agent loop (which has read_file, grep, etc.) instead of the
-        // toolless BMAD SSE workflow which cannot read files and will fabricate.
+        // V3 agent (which archives runs for history/replay/fork and supports
+        // workspace hydration) first.  Falls back to local agent loop if V3
+        // is unreachable.
         if (this.isRepoGroundedPrompt(prompt) && this.tools) {
             this.operatorMode = true;
+            const handledByV3 = await this.tryV3AgentWorkflow(prompt);
+            if (handledByV3) {
+                this.saveSession();
+                return;
+            }
             await this.runLocalAgentLoop(prompt);
             return;
         }
@@ -1431,6 +1464,7 @@ class ChatCommand {
         this.v3IterationCount = 0;
         this.v3ToolCallCount = 0;
         this.v3LastActivity = Date.now();
+        this.v3StreamingStarted = false;
         const spinner = this.jsonOutput ? null : (0, logger_js_1.createSpinner)({
             text: routingPolicy.cloudSelected ? 'Routing heavy task to Vigthoria Cloud...' : 'Routing to V3 Agent...',
             spinner: 'clock',
@@ -1484,6 +1518,10 @@ class ChatCommand {
             if (spinner) {
                 spinner.stop();
             }
+            // End streaming line if we streamed text inline
+            if (this.v3StreamingStarted) {
+                process.stdout.write('\n');
+            }
             const previewGate = (response.metadata?.previewGate || null);
             const workspaceHasOutput = this.api.hasAgentWorkspaceOutput(workspaceContext);
             const success = previewGate?.required === true
@@ -1536,6 +1574,12 @@ class ChatCommand {
                     metadata: response.metadata || {},
                 }, null, 2));
             }
+            else if (this.v3StreamingStarted) {
+                // Content was already streamed to stdout in real-time; skip duplicate print.
+                if (!this.directPromptMode) {
+                    console.log(chalk_1.default.gray(`Agent routing: ${routingPolicy.cloudSelected ? 'Vigthoria Cloud' : 'V3 Agent'} via model ${routingPolicy.selectedModel}`));
+                }
+            }
             else if (response.content) {
                 if (!this.directPromptMode) {
                     console.log(chalk_1.default.gray(`Agent routing: ${routingPolicy.cloudSelected ? 'Vigthoria Cloud' : 'V3 Agent'} via model ${routingPolicy.selectedModel}`));
@@ -1976,10 +2020,11 @@ class ChatCommand {
         if (!this.directPromptMode) {
             return false;
         }
-        if (this.isServerBindableWorkspace(this.currentProjectPath)) {
-            return false;
-        }
-        return /(analyse|analyze|audit|overview|inspect|explain|review|debug|diagnos|read|summari[sz]e|investigate|list|show|find|search|check|scan|count|what|describe)/i.test(prompt);
+        // Always prefer V3 agent first — it supports workspace hydration for
+        // non-server-bindable workspaces (Windows paths, remote machines).
+        // The V3 path will fall back to local-agent-loop if V3 is unreachable.
+        // This ensures runs get archived for history/replay/fork.
+        return false;
     }
     shouldRequireV3AgentWorkflow(prompt) {
         if (!this.directPromptMode) {

package/dist/commands/deploy.js

@@ -127,6 +127,7 @@ class DeployCommand {
      * Deploy to preview URL (free)
      */
     async deployToPreview(projectPath) {
+        this.requireAuth();
         const spinner = (0, logger_js_1.createSpinner)('Deploying to preview...').start();
         try {
             const projectDir = projectPath || process.cwd();
@@ -155,6 +156,7 @@ class DeployCommand {
             this.logger.error('Deploy failed');
             const errMsg = error instanceof Error ? error.message : 'Unknown error';
             console.log(chalk_1.default.red(`\n❌ Error: ${errMsg}\n`));
+            process.exitCode = 1;
         }
     }
     /**

package/dist/commands/fork.d.ts

@@ -11,6 +11,7 @@ export declare class ForkCommand {
     constructor(config: Config, logger: Logger);
     private getHeaders;
     private getBaseUrl;
+    private resolveWorkspaceRoot;
     run(runId: string, message: string, options: ForkOptions): Promise<void>;
 }
 export {};

package/dist/commands/fork.js

@@ -31,18 +31,35 @@ class ForkCommand {
         return headers;
     }
     getBaseUrl() {
+        const configuredApiUrl = String(this.config.get('apiUrl') || 'https://coder.vigthoria.io').replace(/\/$/, '');
+        const allowLocal = process.env.VIGTHORIA_ALLOW_LOCAL_V3_AGENT === '1';
         return (process.env.VIGTHORIA_V3_AGENT_URL ||
             process.env.V3_AGENT_URL ||
-            'http://127.0.0.1:8030');
+            (allowLocal ? 'http://127.0.0.1:8030' : null) ||
+            configuredApiUrl);
+    }
+    resolveWorkspaceRoot(project) {
+        if (/^[a-zA-Z]:[\\/]/.test(project) || /^\\\\/.test(project))
+            return '';
+        if (typeof require !== 'undefined') {
+            try {
+                const path = require('path');
+                if (!path.isAbsolute(project))
+                    return '';
+            }
+            catch { }
+        }
+        return project;
     }
     async run(runId, message, options) {
         const project = options.project || process.cwd();
+        const workspace = this.resolveWorkspaceRoot(project);
         const eventIndex = options.eventIndex || 0;
         const spinner = (0, logger_js_1.createSpinner)(`Forking run ${runId}...`).start();
         try {
             const baseUrl = this.getBaseUrl();
             const body = {
-                workspace_root: project,
+                workspace_root: workspace,
                 from_event_index: eventIndex,
                 new_request: message || '',
                 stream: true,
@@ -58,6 +75,9 @@ class ForkCommand {
                 if (resp.status === 404) {
                     this.logger.error(`Run ${runId} not found or has no event log.`);
                 }
+                else if (resp.status === 502 || resp.status === 503) {
+                    this.logger.error(`V3 run-history route is not available on ${baseUrl}. Backend may not expose /api/runs.`);
+                }
                 else {
                     this.logger.error(`Fork failed: ${resp.status} ${resp.statusText}`);
                 }

package/dist/commands/history.d.ts

@@ -11,6 +11,7 @@ export declare class HistoryCommand {
     constructor(config: Config, logger: Logger);
     private getHeaders;
     private getBaseUrl;
+    private resolveWorkspaceRoot;
     run(options: HistoryOptions): Promise<void>;
 }
 export {};

package/dist/commands/history.js

@@ -31,26 +31,49 @@ class HistoryCommand {
         return headers;
     }
     getBaseUrl() {
+        const configuredApiUrl = String(this.config.get('apiUrl') || 'https://coder.vigthoria.io').replace(/\/$/, '');
+        const allowLocal = process.env.VIGTHORIA_ALLOW_LOCAL_V3_AGENT === '1';
         return (process.env.VIGTHORIA_V3_AGENT_URL ||
             process.env.V3_AGENT_URL ||
-            'http://127.0.0.1:8030');
+            (allowLocal ? 'http://127.0.0.1:8030' : null) ||
+            configuredApiUrl);
+    }
+    resolveWorkspaceRoot(project) {
+        // On Windows or non-absolute paths, send empty so the server uses its fallback root
+        if (/^[a-zA-Z]:[\\/]/.test(project) || /^\\\\/.test(project))
+            return '';
+        if (typeof require !== 'undefined') {
+            try {
+                const path = require('path');
+                if (!path.isAbsolute(project))
+                    return '';
+            }
+            catch { }
+        }
+        return project;
     }
     async run(options) {
         const limit = options.limit || 20;
         const project = options.project || process.cwd();
+        const workspace = this.resolveWorkspaceRoot(project);
         const spinner = (0, logger_js_1.createSpinner)('Loading run history...').start();
         try {
             const baseUrl = this.getBaseUrl();
             const params = new URLSearchParams({
                 limit: String(limit),
-                workspace_root: project,
+                workspace_root: workspace,
             });
             const resp = await fetch(`${baseUrl}/api/runs?${params}`, {
                 headers: this.getHeaders(),
             });
             if (!resp.ok) {
                 spinner.stop();
-                this.logger.error(`Failed to fetch runs: ${resp.status} ${resp.statusText}`);
+                if (resp.status === 404 || resp.status === 502 || resp.status === 503) {
+                    this.logger.error(`V3 run-history route is not available on ${baseUrl}. Backend may not expose /api/runs.`);
+                }
+                else {
+                    this.logger.error(`Failed to fetch runs: ${resp.status} ${resp.statusText}`);
+                }
                 return;
             }
             const data = (await resp.json());

package/dist/commands/replay.d.ts

@@ -11,6 +11,7 @@ export declare class ReplayCommand {
     constructor(config: Config, logger: Logger);
     private getHeaders;
     private getBaseUrl;
+    private resolveWorkspaceRoot;
     private sleep;
     run(runId: string, options: ReplayOptions): Promise<void>;
 }

package/dist/commands/replay.js

@@ -31,9 +31,25 @@ class ReplayCommand {
         return headers;
     }
     getBaseUrl() {
+        const configuredApiUrl = String(this.config.get('apiUrl') || 'https://coder.vigthoria.io').replace(/\/$/, '');
+        const allowLocal = process.env.VIGTHORIA_ALLOW_LOCAL_V3_AGENT === '1';
         return (process.env.VIGTHORIA_V3_AGENT_URL ||
             process.env.V3_AGENT_URL ||
-            'http://127.0.0.1:8030');
+            (allowLocal ? 'http://127.0.0.1:8030' : null) ||
+            configuredApiUrl);
+    }
+    resolveWorkspaceRoot(project) {
+        if (/^[a-zA-Z]:[\\/]/.test(project) || /^\\\\/.test(project))
+            return '';
+        if (typeof require !== 'undefined') {
+            try {
+                const path = require('path');
+                if (!path.isAbsolute(project))
+                    return '';
+            }
+            catch { }
+        }
+        return project;
     }
     sleep(ms) {
         return new Promise((resolve) => setTimeout(resolve, ms));
@@ -41,10 +57,11 @@ class ReplayCommand {
     async run(runId, options) {
         const speed = options.speed || 200;
         const project = options.project || process.cwd();
+        const workspace = this.resolveWorkspaceRoot(project);
         const spinner = (0, logger_js_1.createSpinner)(`Loading events for run ${runId}...`).start();
         try {
             const baseUrl = this.getBaseUrl();
-            const params = new URLSearchParams({ workspace_root: project });
+            const params = new URLSearchParams({ workspace_root: workspace });
             const resp = await fetch(`${baseUrl}/api/runs/${encodeURIComponent(runId)}/events?${params}`, {
                 headers: this.getHeaders(),
             });
@@ -53,6 +70,9 @@ class ReplayCommand {
                 if (resp.status === 404) {
                     this.logger.error(`No event log found for run ${runId}. Events are only recorded for runs made after the replay system was deployed.`);
                 }
+                else if (resp.status === 502 || resp.status === 503) {
+                    this.logger.error(`V3 run-history route is not available on ${baseUrl}. Backend may not expose /api/runs.`);
+                }
                 else {
                     this.logger.error(`Failed to fetch events: ${resp.status} ${resp.statusText}`);
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vigthoria-cli",
-  "version": "1.6.57",
+  "version": "1.6.59",
   "description": "Vigthoria Coder CLI - AI-powered terminal coding assistant",
   "main": "dist/index.js",
   "files": [