Output errors to console instead of dev console

src/buf.ts

@@ -1,4 +1,4 @@
 import * as child_process from "child_process";
 import { Error } from "./errors";
 import { parse, Version } from "./version";
 
@@ -37,13 +37,12 @@
       shell: process.platform === "win32",
     }
   );
-  if (output.error !== undefined) {
-    return { errorMessage: output.error.message };
-  }
-  if (output.status !== null && output.status === 0) {
-    return [];
+  // If the command fails to run, such as a failed module/workspace build, return the error.
+  if (output.status === 1)  {
+    return output.stderr.trim().split("\n");
   }
-  return output.stdout.trim().split("\n");
+  // If the command succeeds with no lint failures and an empty output will be returned.
+  return output.stdout.trim().split("\n").filter((s) => s.trim().length > 0);
 };
 
 export const version = (binaryPath: string): Version | Error => {

src/extension.ts

@@ -8,7 +8,8 @@ import { format, less } from "./version";
 import { getBinaryPath } from "./get-binary-path";
 
 export function activate(context: vscode.ExtensionContext) {
-  const { binaryPath } = getBinaryPath();
+  const outputChannel = vscode.window.createOutputChannel("Buf", "console");
+  const { binaryPath } = getBinaryPath(outputChannel);
   if (binaryPath === undefined) {
     return;
   }
@@ -57,12 +58,13 @@ export function activate(context: vscode.ExtensionContext) {
 
   const diagnosticCollection =
     vscode.languages.createDiagnosticCollection("vscode-buf.lint");
+
   const doLint = (document: vscode.TextDocument) => {
     if (!document.uri.path.endsWith(".proto")) {
       return;
     }
 
-    const { binaryPath, cwd } = getBinaryPath();
+    const { binaryPath, cwd } = getBinaryPath(outputChannel);
     if (binaryPath === undefined) {
       return;
     }
@@ -82,7 +84,8 @@ export function activate(context: vscode.ExtensionContext) {
     }
     const warnings = parseLines(lines);
     if (isError(warnings)) {
-      console.log(warnings);
+      outputChannel.appendLine(warnings.errorMessage);
+      outputChannel.show();
       return;
     }
     const warningsForThisDocument = warnings.filter(
@@ -109,7 +112,7 @@ export function activate(context: vscode.ExtensionContext) {
     diagnosticCollection.set(document.uri, diagnostics);
   };
 
-  const formatter = new Formatter(binaryPath);
+  const formatter = new Formatter(binaryPath, outputChannel);
   context.subscriptions.push(
     vscode.languages.registerDocumentFormattingEditProvider("proto", formatter)
   );

src/formatter.ts

@@ -5,13 +5,15 @@ import * as vscode from "vscode";
 import { TextEncoder } from "util";
 
 export class Formatter implements vscode.DocumentFormattingEditProvider {
+    outputChannel: vscode.OutputChannel | undefined;
     readonly binaryPath: string = '';
 
-    constructor(binaryPath: string) {
+    constructor(binaryPath: string, outputChannel: vscode.OutputChannel) {
         if (!binaryPath || binaryPath.length === 0) {
             throw new Error('binaryPath is required to construct a formatter');
         }
         this.binaryPath = binaryPath;
+        this.outputChannel = outputChannel;
     }
 
     public provideDocumentFormattingEdits(
@@ -26,8 +28,9 @@ export class Formatter implements vscode.DocumentFormattingEditProvider {
         return this.runFormatter(document, token).then(
             (edits) => edits,
             (err) => {
-                console.log(err);
-                return Promise.reject('Check the console in dev tools to find errors when formatting.');
+                this.outputChannel?.appendLine(err);
+                this.outputChannel?.show();
+                return Promise.reject('Check the console to find errors when formatting.');
             }
         );
     }

src/get-binary-path.ts

@@ -6,33 +6,37 @@ import pkg from "../package.json";
 const defaultBinaryPath =
   pkg.contributes.configuration.properties["buf.binaryPath"].default;
 
-const getWorkspaceFolderFsPath = () => {
+const getWorkspaceFolderFsPath = (outputChannel: vscode.OutputChannel) => {
   if (vscode.workspace.workspaceFolders === undefined) {
-    console.log("workspace folders was undefined");
+    outputChannel.appendLine("workspace folders was undefined");
+    outputChannel.show();
     return;
   }
   if (vscode.workspace.workspaceFolders.length === 0) {
-    console.log("workspace folders was not set");
+    outputChannel.appendLine("workspace folders was not set");
+    outputChannel.show();
     return;
   }
   const uri = vscode.workspace.workspaceFolders[0].uri;
   if (uri.scheme !== "file") {
-    console.log("uri was not file: ", uri.scheme);
+    outputChannel.appendLine(`uri was not file: ${uri.scheme}`);
+    outputChannel.show();
     return;
   }
   return uri.fsPath;
 };
 
-export const getBinaryPath = () => {
-  const workspaceFolderFsPath = getWorkspaceFolderFsPath();
+export const getBinaryPath = (outputChannel: vscode.OutputChannel) => {
+  const workspaceFolderFsPath = getWorkspaceFolderFsPath(outputChannel);
   if (workspaceFolderFsPath === undefined) {
     return {};
   }
   let binaryPath = vscode.workspace
     .getConfiguration("buf")!
     .get<string>("binaryPath");
   if (binaryPath === undefined) {
-    console.log("buf binary path was not set");
+    outputChannel.appendLine("buf binary path was not set");
+    outputChannel.show();
     return {};
   }
 
@@ -41,7 +45,8 @@ export const getBinaryPath = () => {
     binaryPath = path.join(workspaceFolderFsPath, binaryPath);
 
     if (!existsSync(binaryPath)) {
-      console.log("buf binary path does not exist: ", binaryPath);
+      outputChannel.appendLine(`buf binary path does not exist: ${binaryPath}`);
+      outputChannel.show();
       return {};
     }
   }

src/parser.ts

@@ -29,15 +29,12 @@ export const parseLines = (errorLines: string[]): Warning[] | Error => {
   for (let index = 0; index < errorLines.length; index++) {
     try {
       const warning = JSON.parse(errorLines[index]);
-      if (!isWarning(warning)) {
-        return {
-          errorMessage: `failed to parse "${errorLines[index]}" as warning`,
-        };
+      if (isWarning(warning)) {
+        warnings.push(warning);
       }
-      warnings.push(warning);
     } catch (error) {
       return {
-        errorMessage: `failed to parse "${errorLines[index]}" as warning: ${error}`,
+        errorMessage: `${errorLines.join(",")}`,
       };
     }
   }

src/test/buf.test.ts

@@ -8,6 +8,7 @@ import path from "path";
 
 suite("Buf CLI tests", () => {
   vscode.window.showInformationMessage("Start all tests.");
+  const outputChannel = vscode.window.createOutputChannel("Buf-test", "console");
 
   test("Default path succeeds when buf is installed", async () => {
     const version = buf.version("buf");
@@ -19,7 +20,7 @@ suite("Buf CLI tests", () => {
   });
 
   test("Relative path loaded from config", async () => {
-    const { binaryPath } = getBinaryPath();
+    const { binaryPath } = getBinaryPath(outputChannel);
     assert.ok(binaryPath);
     const version = buf.version(binaryPath);
     if ("errorMessage" in version) {
@@ -33,7 +34,7 @@ suite("Buf CLI tests", () => {
     let storedPath: string | undefined;
 
     setup(() => {
-      const { cwd } = getBinaryPath();
+      const { cwd } = getBinaryPath(outputChannel);
       storedPath = vscode.workspace
         .getConfiguration("buf")
         .get<string>("binaryPath");
@@ -50,7 +51,7 @@ suite("Buf CLI tests", () => {
     });
 
     test("version", async () => {
-      const { binaryPath } = getBinaryPath();
+      const { binaryPath } = getBinaryPath(outputChannel);
       assert.ok(binaryPath);
       const version = buf.version(binaryPath);
       if ("errorMessage" in version) {