vigthoria-cli 1.13.13 → 1.13.20

package/dist/index.js

@@ -49,6 +49,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
 import { fileURLToPath } from 'url';
+import { createRequire } from 'module';
 import { createHash } from 'crypto';
 import axios from 'axios';
 import { renderDynamicHelp, selectInteractiveCommand } from './utils/command-menu.js';
@@ -472,10 +473,10 @@ async function enforceGatewayAuthSession(config, logger, jsonOutputRequested) {
     if (isLocalTestfarmMode()) {
         return true;
     }
-    if (!config.isAuthenticated()) {
+    const explicitEnvToken = Boolean(process.env.VIGTHORIA_TOKEN || process.env.VIGTHORIA_AUTH_TOKEN);
+    if (!config.isAuthenticated() && !explicitEnvToken) {
         return true;
     }
-    const explicitEnvToken = Boolean(process.env.VIGTHORIA_TOKEN || process.env.VIGTHORIA_AUTH_TOKEN);
     // Offline mode disables every outbound preflight call.
     if (isOfflineMode()) {
         return true;
@@ -1317,6 +1318,7 @@ Examples:
         .command('start <prompt...>')
         .description('Start an Agent job in the background and return immediately')
         .option('--workspace <path>', 'Local workspace path', process.cwd())
+        .option('--model <model>', 'Execution lane: agent, cloud, cloud-reason, or ultra', 'agent')
         .option('--json', 'Emit JSON output', false)
         .action(async (prompt, options) => {
         const bg = new BackgroundCommand(config, logger);
@@ -1357,6 +1359,15 @@ Examples:
         const bg = new BackgroundCommand(config, logger);
         await bg.cancel(jobId, options);
     });
+    backgroundCommand
+        .command('approve <jobId> <approvalId>')
+        .description('Resolve a pending two-stage command gate for a background job')
+        .option('--deny', 'Deny the command instead of approving it', false)
+        .option('--json', 'Emit JSON output', false)
+        .action(async (jobId, approvalId, options) => {
+        const bg = new BackgroundCommand(config, logger);
+        await bg.approve(jobId, approvalId, options);
+    });
     backgroundCommand.action(() => {
         backgroundCommand.outputHelp();
     });
@@ -1598,9 +1609,57 @@ Examples:
                 : process.platform === 'win32' || process.platform === 'linux'
                     ? 'supported-desktop'
                     : 'unsupported';
+        const nodeMatch = process.versions.node.match(/^(\d+)\.(\d+)/);
+        const nodeCompatible = Boolean(nodeMatch && (Number(nodeMatch[1]) > 20
+            || (Number(nodeMatch[1]) === 20 && Number(nodeMatch[2]) >= 19)));
+        const runtimeRequire = createRequire(import.meta.url);
+        const requiredRuntimePackages = ['axios', 'commander', 'inquirer', 'ws'];
+        const missingRuntimePackages = requiredRuntimePackages.filter((name) => {
+            try {
+                runtimeRequire.resolve(name);
+                return false;
+            }
+            catch {
+                return true;
+            }
+        });
+        const sessionsDir = path.join(os.homedir(), '.vigthoria', 'sessions');
+        let sessionStorageWritable = false;
+        let latestCheckpoint = null;
+        try {
+            fs.mkdirSync(sessionsDir, { recursive: true, mode: 0o700 });
+            const probePath = path.join(sessionsDir, `.doctor-${process.pid}-${Date.now()}.tmp`);
+            fs.writeFileSync(probePath, '{}', { encoding: 'utf8', mode: 0o600 });
+            fs.unlinkSync(probePath);
+            sessionStorageWritable = true;
+            const latestSessionFile = fs.readdirSync(sessionsDir)
+                .filter((name) => name.endsWith('.json'))
+                .map((name) => ({ name, mtime: fs.statSync(path.join(sessionsDir, name)).mtimeMs }))
+                .sort((left, right) => right.mtime - left.mtime)[0]?.name;
+            if (latestSessionFile) {
+                const persisted = JSON.parse(fs.readFileSync(path.join(sessionsDir, latestSessionFile), 'utf8'));
+                const checkpoint = persisted?.activeAgentRun;
+                if (checkpoint && typeof checkpoint === 'object') {
+                    latestCheckpoint = {
+                        executionId: checkpoint.executionId || null,
+                        status: checkpoint.status || null,
+                        updatedAt: checkpoint.updatedAt || null,
+                        resumable: ['submitted', 'running', 'failed'].includes(String(checkpoint.status || '')),
+                    };
+                }
+            }
+        }
+        catch {
+            sessionStorageWritable = false;
+        }
+        const envToken = String(process.env.VIGTHORIA_AUTH_TOKEN || process.env.VIGTHORIA_TOKEN || '').trim();
+        const configuredToken = envToken || String(config.get('authToken') || '').trim();
+        const tokenSegments = configuredToken ? configuredToken.split('.').length : 0;
         const report = {
             cliVersion: VERSION,
             nodeVersion: process.version,
+            nodeCompatible,
+            runtimeDependencies: missingRuntimePackages.length === 0 ? 'complete' : `missing: ${missingRuntimePackages.join(', ')}`,
             platform: `${process.platform} ${process.arch}`,
             clientOs: resolveClientOsSlug(),
             platformSupport,
@@ -1614,6 +1673,14 @@ Examples:
             apiUrl,
             modelsApiUrl,
             loggedIn: config.isAuthenticated(),
+            authToken: configuredToken
+                ? { present: true, source: envToken ? 'environment' : 'secure-config', structure: tokenSegments === 3 ? 'jwt' : 'opaque' }
+                : { present: false, source: null, structure: null },
+            sessionPersistence: {
+                directory: sessionsDir,
+                writable: sessionStorageWritable,
+                latestCheckpoint,
+            },
             subscriptionPlan: subscription.plan || null,
             subscriptionStatus: subscription.status || null,
             offlineMode: offline,
@@ -1628,20 +1695,52 @@ Examples:
             },
         };
         if (options.checkApi && !offline) {
+            const api = new APIClient(config, logger);
+            if (configuredToken) {
+                try {
+                    const tokenCheck = await api.validateToken({ allowNetworkFailOpen: false, enforceTokenShape: true });
+                    report.authValidation = tokenCheck.valid ? 'authenticated' : `failed (${tokenCheck.error || 'invalid token'})`;
+                }
+                catch (error) {
+                    report.authValidation = `unreachable (${sanitizeUserFacingErrorText(error.message)})`;
+                }
+            }
+            else {
+                report.authValidation = 'not checked (login required)';
+            }
             try {
-                const probe = await axios.get(`${apiUrl}/api/health`, { timeout: 4000, validateStatus: () => true });
+                const probe = await axios.get(`${apiUrl}/api/health`, { timeout: 12000, validateStatus: () => true });
                 report.apiHealth = probe.status >= 200 && probe.status < 400 ? 'online' : `status ${probe.status}`;
             }
             catch (error) {
                 report.apiHealth = `unreachable (${error.message})`;
             }
             try {
-                const probe = await axios.get(`${modelsApiUrl}/health`, { timeout: 4000, validateStatus: () => true });
-                report.modelsApiHealth = probe.status >= 200 && probe.status < 400 ? 'online' : `status ${probe.status}`;
+                const probe = await axios.get(`${modelsApiUrl}/health`, { timeout: 12000, validateStatus: () => true });
+                const body = typeof probe.data === 'string' ? probe.data : JSON.stringify(probe.data || {});
+                report.modelsApiHealth = probe.status >= 200 && probe.status < 400
+                    ? 'online'
+                    : probe.status === 503 && /pre-release validation|closed/i.test(body)
+                        ? 'pre-release-closed (Agent mode uses the Coder gateway)'
+                        : `status ${probe.status}`;
             }
             catch (error) {
                 report.modelsApiHealth = `unreachable (${error.message})`;
             }
+            if (configuredToken) {
+                try {
+                    const capabilities = await api.getCapabilityTruthStatus({ workspacePath: process.cwd() });
+                    report.agentInfrastructure = {
+                        overall: capabilities.overallOk ? 'online' : 'degraded',
+                        v3Agent: capabilities.v3Agent.ok ? 'online' : capabilities.v3Agent.error || 'offline',
+                        hyperLoop: capabilities.hyperLoop.ok ? 'online' : capabilities.hyperLoop.error || 'offline',
+                        repoMemory: capabilities.repoMemory.ok ? 'online' : capabilities.repoMemory.error || 'offline',
+                    };
+                }
+                catch (error) {
+                    report.agentInfrastructure = `unreachable (${sanitizeUserFacingErrorText(error.message)})`;
+                }
+            }
         }
         if (options.json) {
             console.log(JSON.stringify(report, null, 2));
@@ -1663,7 +1762,9 @@ Examples:
                 console.log(chalk.gray('\nTip: pass --check-api to verify API reachability.'));
             }
         }
-        process.exitCode = 0;
+        const requiredLocalChecksPassed = nodeCompatible && missingRuntimePackages.length === 0 && sessionStorageWritable;
+        const coderReachable = !options.checkApi || offline || report.apiHealth === 'online';
+        process.exitCode = requiredLocalChecksPassed && coderReachable ? 0 : 1;
     });
     // Config command
     program

package/dist/utils/api.d.ts

@@ -261,6 +261,7 @@ export declare class APIClient {
     getV3AgentRunUrl(baseUrl: string): string;
     getV3AgentContinueUrl(baseUrl: string): string;
     getV3AgentBackgroundUrl(baseUrl: string, suffix?: string): string;
+    getV3AgentApprovalUrl(baseUrl: string): string;
     getOperatorBaseUrls(): string[];
     getOperatorStreamUrl(baseUrl: string): string;
     getMcpBaseUrls(): string[];
@@ -359,6 +360,11 @@ export declare class APIClient {
     private buildPublicWorkspaceDescriptor;
     private buildPublicRuntimeEnvironment;
     private buildLocalWorkspaceSummary;
+    /**
+     * Build complete workspace hydration separately from model context.
+     * Context compaction must not become filesystem compaction.
+     */
+    private buildOutOfBandWorkspaceFiles;
     /**
      * Collect text file contents from the workspace for V3 agent hydration.
      * Budget: up to ~2 MB total, per-file cap 200 KB, skip binary extensions.
@@ -405,6 +411,7 @@ export declare class APIClient {
     listV3BackgroundJobs(limit?: number): Promise<any[]>;
     getV3BackgroundJob(jobId: string): Promise<any>;
     cancelV3BackgroundJob(jobId: string): Promise<any>;
+    resolveV3BackgroundApproval(jobId: string, approvalId: string, approved: boolean, allowMode?: string): Promise<any>;
     getV3BackgroundJobFiles(jobId: string): Promise<{
         status: string;
         files: Record<string, string>;