vigthoria-cli 1.12.0 → 1.12.2

package/dist/commands/agent-session-menu.d.ts

@@ -3,12 +3,14 @@ export interface AgentSessionConfig {
     debugMode: boolean;
     autoApprove: boolean;
     autoSave: boolean;
+    engine: 'v3' | 'v4';
 }
 export interface AgentSessionMenuDefaults {
     workspacePath?: string;
     debugMode?: boolean;
     autoApprove?: boolean;
     autoSave?: boolean;
+    engine?: 'v3' | 'v4';
 }
 export interface AgentSessionMenuOptions {
     prompt?: string;

package/dist/commands/agent-session-menu.js

@@ -90,12 +90,34 @@ export async function runAgentSessionMenu(defaults = {}) {
         debugMode: defaults.debugMode === true,
         autoApprove: defaults.autoApprove === true,
         autoSave: defaults.autoSave !== false,
+        engine: defaults.engine === 'v4' ? 'v4' : 'v3',
     };
     console.log();
     console.log(chalk.cyan('═══ Agent Session Setup ═══'));
     console.log(chalk.gray(fitLine(`Workspace: ${session.workspacePath}`)));
     console.log(chalk.gray(fitLine(`Debug: ${session.debugMode ? 'on' : 'off'} | Auto-approve: ${session.autoApprove ? 'on' : 'off'} | Auto-save: ${session.autoSave ? 'on' : 'off'}`)));
     console.log();
+    const { engine } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'engine',
+            message: 'Agent engine',
+            default: session.engine,
+            choices: [
+                { name: 'V3 Code Agent (default, stable)', value: 'v3' },
+                { name: 'V4 Operating Agent (experimental, requires local V4-Operating-Agent checkout)', value: 'v4' },
+            ],
+        },
+    ]);
+    session.engine = engine;
+    if (session.engine === 'v4') {
+        console.log();
+        console.log(chalk.cyan('── Session ready ──'));
+        console.log(chalk.gray(fitLine(`Workspace: ${session.workspacePath}`)));
+        console.log(chalk.gray('Engine: V4 Operating Agent'));
+        console.log();
+        return session;
+    }
     const { action } = await inquirer.prompt([
         {
             type: 'list',

package/dist/commands/chat.js

@@ -14,6 +14,7 @@ import { ProjectMemoryService } from '../utils/project-memory.js';
 import { WorkspaceBrainService } from '../utils/workspace-brain-service.js';
 import { buildPersonaOverlay, normalizePersonaMode } from '../utils/persona.js';
 import { runAgentSessionMenu, shouldShowAgentSessionMenu } from './agent-session-menu.js';
+import { V4Command } from './v4.js';
 import { createLiveOutcome, evaluateExecutorSuccess, handleTaskEvent, isSubstantiveAgentAnswer, isToolEvidenceStubAnswer, normalizeAgentAnswerContent, noteAnalysisToolUse, } from '../utils/agentRunOutcome.js';
 import { looksLikeMarkdownReport, renderMarkdownToTerminal, summarizeMarkdownReport, } from '../utils/terminalMarkdown.js';
 import { emitDeckEvent, isDeckModeEnabled } from '../utils/deckEvents.js';
@@ -1503,6 +1504,11 @@ export class ChatCommand {
             if (sessionConfig.debugMode) {
                 process.env.DEBUG = process.env.DEBUG || 'vigthoria:*';
             }
+            if (sessionConfig.engine === 'v4') {
+                const v4 = new V4Command(this.config, this.logger);
+                await v4.run({ v4Path: process.env.VIGTHORIA_V4_AGENT_DIR });
+                return;
+            }
             console.log(chalk.green(this.fitTerminalText(`Using workspace: ${this.currentProjectPath}`)));
         }
         if (this.jsonOutput && !options.prompt && !options.retry && !options.continue) {

package/dist/commands/v4-menu.d.ts

@@ -0,0 +1,9 @@
+export interface V4MenuOptions {
+    defaultAgent?: string;
+    defaultProvider?: string;
+    byokApiKey?: string;
+    byokBaseUrl?: string;
+    byokModel?: string;
+    outFile: string;
+}
+export declare function runV4Menu(options: V4MenuOptions): Promise<void>;

package/dist/commands/v4-menu.js

@@ -0,0 +1,136 @@
+/**
+ * Interactive V3/V4 agent + V4 provider picker, styled to match the rest of
+ * the Vigthoria CLI's menus (see agent-session-menu.ts). This is invoked as a
+ * subprocess (with inherited stdio, so it keeps full TTY/inquirer rendering)
+ * by the V4 Operating Agent's Python launcher (cli_menu.py) instead of that
+ * project rendering its own boxed prompt_toolkit dialog, which looked
+ * inconsistent with the CLI's visual design.
+ *
+ * The result is written as JSON to --out-file rather than printed to stdout,
+ * so stdout can stay fully interactive (a piped stdout would make inquirer
+ * fall back to non-interactive/plain rendering).
+ */
+import * as fs from 'fs';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+function isCancelError(error) {
+    const name = error instanceof Error ? error.name : '';
+    return name === 'ExitPromptError' || name === 'ERR_CLOSED';
+}
+function writeResult(outFile, result) {
+    fs.writeFileSync(outFile, JSON.stringify(result), 'utf8');
+}
+export async function runV4Menu(options) {
+    const defaultAgent = options.defaultAgent === 'v4' ? 'v4' : 'v3';
+    const defaultProvider = options.defaultProvider === 'v3_local' || options.defaultProvider === 'byok'
+        ? options.defaultProvider
+        : 'cloud';
+    console.log();
+    console.log(chalk.cyan('═══ Vigthoria Agent Launcher ═══'));
+    console.log(chalk.gray('Choose which agent runtime to start.'));
+    console.log();
+    try {
+        const { agent } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'agent',
+                message: 'Select runtime',
+                default: defaultAgent,
+                choices: [
+                    { name: 'V3 Code Agent', value: 'v3' },
+                    { name: 'V4 Operating Agent', value: 'v4' },
+                ],
+            },
+        ]);
+        if (agent === 'v3') {
+            console.log();
+            console.log(chalk.cyan('── Session ready ──'));
+            console.log(chalk.gray('Runtime: V3 Code Agent'));
+            console.log();
+            writeResult(options.outFile, { agent: 'v3' });
+            return;
+        }
+        const { provider } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'provider',
+                message: 'Select V4 backend',
+                default: defaultProvider,
+                choices: [
+                    { name: 'Vigthoria Cloud (Gateway + Session Wallet Token)', value: 'cloud' },
+                    { name: 'Vigthoria V3 Local (Blackwell 35B Direct)', value: 'v3_local' },
+                    { name: 'Bring Your Own Key (API Key + Base URL + Model)', value: 'byok' },
+                ],
+            },
+        ]);
+        if (provider !== 'byok') {
+            console.log();
+            console.log(chalk.cyan('── Session ready ──'));
+            console.log(chalk.gray(`Runtime: V4 Operating Agent (${provider === 'cloud' ? 'Vigthoria Cloud' : 'Vigthoria V3 Local'})`));
+            console.log();
+            writeResult(options.outFile, { agent: 'v4', provider });
+            return;
+        }
+        const existingApiKey = String(options.byokApiKey || '').trim();
+        const existingBaseUrl = String(options.byokBaseUrl || '').trim();
+        const existingModel = String(options.byokModel || '').trim();
+        const missing = !existingApiKey || !existingBaseUrl || !existingModel;
+        const questions = [];
+        if (!existingApiKey) {
+            questions.push({
+                type: 'password',
+                name: 'apiKey',
+                message: 'BYOK API key:',
+                mask: '*',
+                validate: (value) => (String(value || '').trim() ? true : 'API key is required.'),
+            });
+        }
+        if (!existingBaseUrl) {
+            questions.push({
+                type: 'input',
+                name: 'baseUrl',
+                message: 'BYOK base URL:',
+                validate: (value) => (String(value || '').trim() ? true : 'Base URL is required.'),
+            });
+        }
+        if (!existingModel) {
+            questions.push({
+                type: 'input',
+                name: 'model',
+                message: 'BYOK default model:',
+                validate: (value) => (String(value || '').trim() ? true : 'Model is required.'),
+            });
+        }
+        const answers = questions.length > 0 ? await inquirer.prompt(questions) : {};
+        const apiKey = String(answers.apiKey || existingApiKey).trim();
+        const baseUrl = String(answers.baseUrl || existingBaseUrl).trim();
+        const model = String(answers.model || existingModel).trim();
+        let save = false;
+        if (missing) {
+            const { saveLocally } = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'saveLocally',
+                    message: 'Store BYOK values locally in ~/.config/vigthoria/config.yaml?',
+                    default: true,
+                },
+            ]);
+            save = saveLocally;
+        }
+        console.log();
+        console.log(chalk.cyan('── Session ready ──'));
+        console.log(chalk.gray('Runtime: V4 Operating Agent (Bring Your Own Key)'));
+        console.log();
+        writeResult(options.outFile, { agent: 'v4', provider: 'byok', apiKey, baseUrl, model, save });
+    }
+    catch (error) {
+        if (isCancelError(error)) {
+            console.log();
+            console.log(chalk.yellow('Cancelled.'));
+            writeResult(options.outFile, { cancelled: true });
+            process.exitCode = 130;
+            return;
+        }
+        throw error;
+    }
+}

package/dist/commands/v4.d.ts

@@ -1,6 +1,8 @@
 import { Command } from 'commander';
 import { Config } from '../utils/config.js';
 import { Logger } from '../utils/logger.js';
+export declare function defaultV4PythonBin(): string;
+export declare function defaultV4AgentDir(): string | undefined;
 type V4Options = {
     provider?: 'cloud' | 'v3_local' | 'byok';
     apiKey?: string;

package/dist/commands/v4.js

@@ -2,6 +2,23 @@ import { spawn } from 'child_process';
 import * as fs from 'fs';
 import * as path from 'path';
 import chalk from 'chalk';
+const DEFAULT_V4_AGENT_DIR_UNIX = '/var/www/V4-Operating-Agent';
+export function defaultV4PythonBin() {
+    return process.env.VIGTHORIA_V4_PYTHON || (process.platform === 'win32' ? 'python' : 'python3');
+}
+export function defaultV4AgentDir() {
+    if (process.env.VIGTHORIA_V4_AGENT_DIR) {
+        return process.env.VIGTHORIA_V4_AGENT_DIR;
+    }
+    // The historical hardcoded default only ever existed on this project's Linux
+    // dev/test boxes. Never assume it on Windows/macOS — only use it as a
+    // fallback when it actually exists on disk, so real users get a clear
+    // "not found" error instead of a silently-wrong path.
+    if (process.platform !== 'win32' && fs.existsSync(DEFAULT_V4_AGENT_DIR_UNIX)) {
+        return DEFAULT_V4_AGENT_DIR_UNIX;
+    }
+    return undefined;
+}
 export class V4Command {
     _config;
     logger;
@@ -23,18 +40,22 @@ export class V4Command {
             .option('--harness-control-url <url>', 'Override harness control URL')
             .option('--session-id <id>', 'Explicit V4 session id')
             .option('--non-interactive', 'Disable interactive menu and use CLI options', false)
-            .option('--python <bin>', 'Python binary to use', process.env.VIGTHORIA_V4_PYTHON || 'python3')
-            .option('--v4-path <path>', 'V4 agent root path', process.env.VIGTHORIA_V4_AGENT_DIR || '/var/www/V4-Operating-Agent')
+            .option('--python <bin>', 'Python binary to use', defaultV4PythonBin())
+            .option('--v4-path <path>', 'V4 agent root path (or set VIGTHORIA_V4_AGENT_DIR)', defaultV4AgentDir())
             .action(async (options) => {
             await this.run(options);
         });
     }
     async run(options) {
-        const v4Path = path.resolve(String(options.v4Path || '/var/www/V4-Operating-Agent'));
-        const pythonBin = String(options.python || 'python3');
+        const resolvedV4Path = options.v4Path || defaultV4AgentDir();
+        if (!resolvedV4Path) {
+            throw Object.assign(new Error('V4 agent path not set. Pass --v4-path <dir> or set the VIGTHORIA_V4_AGENT_DIR environment variable.'), { skipPathScrub: true });
+        }
+        const v4Path = path.resolve(String(resolvedV4Path));
+        const pythonBin = String(options.python || defaultV4PythonBin());
         const mainScript = path.join(v4Path, 'main_agent.py');
         if (!fs.existsSync(mainScript)) {
-            throw new Error(`V4 launcher not found: ${mainScript}`);
+            throw Object.assign(new Error(`V4 launcher not found: ${mainScript}. Check --v4-path/VIGTHORIA_V4_AGENT_DIR points at a valid V4-Operating-Agent checkout.`), { skipPathScrub: true });
         }
         const args = [mainScript];
         if (options.nonInteractive) {

package/dist/index.js

@@ -38,7 +38,8 @@ import { ForkCommand } from './commands/fork.js';
 import { CancelCommand } from './commands/cancel.js';
 import { BackgroundCommand } from './commands/background.js';
 import { SecurityCommand } from './commands/security.js';
-import { V4Command } from './commands/v4.js';
+import { V4Command, defaultV4PythonBin, defaultV4AgentDir } from './commands/v4.js';
+import { runV4Menu } from './commands/v4-menu.js';
 import { Config } from './utils/config.js';
 import { Logger, CH } from './utils/logger.js';
 import chalk from 'chalk';
@@ -473,8 +474,14 @@ function normalizeCliError(error) {
                 ? extended.response.data.message
                 : undefined;
         const rawMessage = responseMessage || extended.message || 'An unexpected CLI error occurred.';
+        // Purely local, client-side errors (e.g. "this config path doesn't exist
+        // on YOUR machine") can legitimately mention local paths that happen to
+        // look like internal server paths (e.g. `/var/www/...`-style directories
+        // the user copied/typed themselves). Scrubbing those makes an otherwise
+        // actionable message unreadable, so commands that construct their own
+        // local filesystem errors can opt out via `skipPathScrub`.
         return {
-            message: scrubMessageForUser(rawMessage),
+            message: extended.skipPathScrub ? rawMessage : scrubMessageForUser(rawMessage),
             code: extended.code,
             status: extended.status || extended.statusCode || extended.response?.status,
             details: extended.details || extended.response?.data,
@@ -753,8 +760,8 @@ export async function main(args) {
         .option('--harness-control-url <url>', 'Override harness control URL')
         .option('--session-id <id>', 'Explicit V4 session id')
         .option('--non-interactive', 'Disable interactive menu and use CLI options', false)
-        .option('--python <bin>', 'Python binary to use', process.env.VIGTHORIA_V4_PYTHON || 'python3')
-        .option('--v4-path <path>', 'V4 agent root path', process.env.VIGTHORIA_V4_AGENT_DIR || '/var/www/V4-Operating-Agent')
+        .option('--python <bin>', 'Python binary to use', defaultV4PythonBin())
+        .option('--v4-path <path>', 'V4 agent root path (or set VIGTHORIA_V4_AGENT_DIR)', defaultV4AgentDir())
         .action(async (options) => {
         const v4 = new V4Command(config, logger);
         await v4.run({
@@ -771,6 +778,25 @@ export async function main(args) {
             v4Path: options.v4Path,
         });
     });
+    program
+        .command('v4-menu')
+        .description('Internal: interactive V3/V4 agent + provider picker used by the V4 Operating Agent launcher')
+        .option('--default-agent <agent>', 'v3 | v4', 'v3')
+        .option('--default-provider <provider>', 'cloud | v3_local | byok', 'cloud')
+        .option('--byok-api-key <key>', 'Existing BYOK api key', '')
+        .option('--byok-base-url <url>', 'Existing BYOK base url', '')
+        .option('--byok-model <name>', 'Existing BYOK model', '')
+        .requiredOption('--out-file <path>', 'Write JSON selection result to this file')
+        .action(async (options) => {
+        await runV4Menu({
+            defaultAgent: options.defaultAgent,
+            defaultProvider: options.defaultProvider,
+            byokApiKey: options.byokApiKey,
+            byokBaseUrl: options.byokBaseUrl,
+            byokModel: options.byokModel,
+            outFile: options.outFile,
+        });
+    });
     program
         .command('bridge')
         .description('Inspect local DevTools Bridge availability for browser debugging tasks')

package/dist/utils/templateInstantPath.js

@@ -124,9 +124,17 @@ function minimalHelloWorldHtml(popupMessage = 'Hello World') {
 </html>
 `;
 }
+// The Template Service (port 4011) hard-rejects any `vision` payload over
+// 2000 characters with an HTTP 400. Real prompts (especially resumed-session
+// `/retry` context on an existing project) routinely exceed that, which
+// otherwise made this fast-path fail every single time for non-trivial
+// requests instead of ever getting a chance to match. Cap to the server's
+// own limit so template matching still gets a fair shot on long prompts.
+const TEMPLATE_SERVICE_MAX_VISION_CHARS = 2000;
 async function fetchTemplateMatch(api, vision, timeoutMs = 15000) {
     const bases = api.getTemplateServiceBaseUrls();
     let lastError = 'Template Service unreachable';
+    const boundedVision = String(vision || '').slice(0, TEMPLATE_SERVICE_MAX_VISION_CHARS);
     for (const base of bases) {
         const controller = new AbortController();
         const timer = setTimeout(() => controller.abort(), timeoutMs);
@@ -134,7 +142,7 @@ async function fetchTemplateMatch(api, vision, timeoutMs = 15000) {
             const response = await fetch(`${base}/match`, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({ vision }),
+                body: JSON.stringify({ vision: boundedVision }),
                 signal: controller.signal,
             });
             clearTimeout(timer);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vigthoria-cli",
-  "version": "1.12.0",
+  "version": "1.12.2",
   "description": "Vigthoria Coder CLI - AI-powered terminal coding assistant",
   "type": "module",
   "main": "dist/index.js",