Simplify CLI integration by using the new spawn function instead of manually managing CLI paths and spawning processes. (#131)

fixes #130

---------

Signed-off-by: karan-palan <karanpalan007@gmail.com>

Author: Karan-Palan

Makefile

@@ -25,6 +25,7 @@ vscode: .always
 	$(INSTALL) -m 0664 vscode/package.json build/vscode/package.json
 	$(JQ) '.main = "./extension.js"' vscode/package.json > build/vscode/package.json
 	$(INSTALL) -m 0664 vscode/package-lock.json build/vscode/package-lock.json
+	cd build/vscode && $(NPM) ci
 
 vscode-test: .always
 	cd test/vscode && $(NPM) ci

test/vscode/extension.test.ts

@@ -142,7 +142,8 @@ suite('Extension Test Suite', () => {
         await new Promise(resolve => setTimeout(resolve, 10000));
 
         const diagnostics = vscode.languages.getDiagnostics(document.uri);
-        assert.strictEqual(diagnostics.length, 0, 'Schema with HTTP $ref should have no diagnostic errors');
+        const errors = diagnostics.filter(d => d.severity === vscode.DiagnosticSeverity.Error);
+        assert.strictEqual(errors.length, 0, 'Schema with HTTP $ref should have no diagnostic errors');
 
         assert.ok(extension?.isActive, 'Extension should remain active after processing HTTP $ref');
     });

vscode/esbuild.js

@@ -14,7 +14,7 @@ async function main() {
     sourcesContent: false,
     platform: 'node',
     outfile: path.join(__dirname, '../build/vscode/extension.js'),
-    external: ['vscode'],
+    external: ['vscode', '@sourcemeta/jsonschema'],
     logLevel: 'silent',
     plugins: [
       {

vscode/package-lock.json

@@ -56,7 +56,7 @@
     "lint": "eslint src --ext ts"
   },
   "dependencies": {
-    "@sourcemeta/jsonschema": "^13.1.0"
+    "@sourcemeta/jsonschema": "^13.3.0"
   },
   "devDependencies": {
     "@types/node": "24.x",

vscode/package.json

@@ -1,62 +1,34 @@
-import { spawn } from 'child_process';
-import { join } from 'path';
+import { spawn } from '@sourcemeta/jsonschema';
 import { CommandResult } from '../../../protocol/types';
 
 /**
  * Execute a CLI command and return the result
  */
 export class CommandExecutor {
-    private readonly extensionPath: string;
-    private readonly cliPath: string;
-
-    constructor(extensionPath: string) {
-        this.extensionPath = extensionPath;
-        this.cliPath = join(extensionPath, 'node_modules', '@sourcemeta', 'jsonschema', 'npm', 'cli.js');
-    }
-
     /**
      * Execute a command with given arguments
      */
-    private async executeCommand(args: string[]): Promise<CommandResult> {
-        return new Promise((resolve, reject) => {
-            const child = spawn(process.execPath, [this.cliPath, ...args], {
-                cwd: this.extensionPath,
-                shell: false,
-                // Do not open a command prompt on spawning
-                windowsHide: true
-            });
-
-            let stdout = '';
-            let stderr = '';
-
-            child.stdout.on('data', (data) => {
-                stdout += data.toString();
-            });
-
-            child.stderr.on('data', (data) => {
-                stderr += data.toString();
-            });
-
-            child.on('close', (code) => {
-                const output = stdout || stderr || 'No output';
-                resolve({
-                    output: output.trim(),
-                    exitCode: code
-                });
-            });
-
-            child.on('error', (error) => {
-                reject(error);
-            });
-        });
+    private async executeCommand(args: string[], json: boolean = true): Promise<CommandResult> {
+        try {
+            const result = await spawn(args, { json });
+            const output = json && typeof result.stdout !== 'string'
+                ? JSON.stringify(result.stdout)
+                : (result.stdout || result.stderr || 'No output');
+            return {
+                output: typeof output === 'string' ? output.trim() : JSON.stringify(output).trim(),
+                exitCode: result.code
+            };
+        } catch (error) {
+            throw error;
+        }
     }
 
     /**
      * Get the JSON Schema CLI version
      */
     async getVersion(): Promise<string> {
         try {
-            const result = await this.executeCommand(['version']);
+            const result = await this.executeCommand(['version'], false);
             return result.exitCode === 0 ? result.output.trim() : `Error: ${result.output}`;
         } catch (error) {
             return `Error: ${(error as Error).message}`;
@@ -68,12 +40,12 @@ export class CommandExecutor {
      */
     async lint(filePath: string, useHttp: boolean = true): Promise<string> {
         try {
-            const args = ['lint', '--json'];
+            const args = ['lint'];
             if (useHttp) {
                 args.push('--http');
             }
             args.push(filePath);
-            const result = await this.executeCommand(args);
+            const result = await this.executeCommand(args, true);
             return result.output;
         } catch (error) {
             throw error;
@@ -85,12 +57,12 @@ export class CommandExecutor {
      */
     async formatCheck(filePath: string, useHttp: boolean = true): Promise<CommandResult> {
         try {
-            const args = ['fmt', '--check', '--json'];
+            const args = ['fmt', '--check'];
             if (useHttp) {
                 args.push('--http');
             }
             args.push(filePath);
-            return await this.executeCommand(args);
+            return await this.executeCommand(args, true);
         } catch (error) {
             throw error;
         }
@@ -100,12 +72,12 @@ export class CommandExecutor {
      * Run format command on a file
      */
     async format(filePath: string, useHttp: boolean = true): Promise<void> {
-        const args = ['fmt', '--json'];
+        const args = ['fmt'];
         if (useHttp) {
             args.push('--http');
         }
         args.push(filePath);
-        const result = await this.executeCommand(args);
+        const result = await this.executeCommand(args, true);
         if (result.exitCode !== 0) {
             try {
                 const errorObj = JSON.parse(result.output);
@@ -124,12 +96,12 @@ export class CommandExecutor {
      */
     async metaschema(filePath: string, useHttp: boolean = true): Promise<CommandResult> {
         try {
-            const args = ['metaschema', '--json'];
+            const args = ['metaschema'];
             if (useHttp) {
                 args.push('--http');
             }
             args.push(filePath);
-            return await this.executeCommand(args);
+            return await this.executeCommand(args, true);
         } catch (error) {
             throw error;
         }

vscode/src/commands/CommandExecutor.ts

@@ -43,7 +43,7 @@ export async function activate(context: vscode.ExtensionContext): Promise<void>
     }
 
     panelManager = new PanelManager(context.extensionPath);
-    commandExecutor = new CommandExecutor(context.extensionPath);
+    commandExecutor = new CommandExecutor();
     diagnosticManager = new DiagnosticManager();
 
     diagnosticManager.getCollections().forEach(collection => {