Merge pull request #2560 from posit-dev/mnv-renv

`renv` setup -  Provide users with an easy solution for renv errors

extensions/vscode/src/eventErrors.ts

@@ -36,6 +36,18 @@ type renvPackageEvtErr = baseEvtErr & {
   libraryVersion: string;
 };
 
+export type RenvAction =
+  | "renvsetup"
+  | "renvinit"
+  | "renvsnapshot"
+  | "renvstatus";
+
+export type renvSetupEvtErr = baseEvtErr & {
+  command: string;
+  action: RenvAction;
+  actionLabel: string;
+};
+
 export const isEvtErrDeploymentFailed = (
   emsg: EventStreamMessageErrorCoded,
 ): emsg is EventStreamMessageErrorCoded<baseEvtErr> => {
@@ -60,6 +72,15 @@ export const isEvtErrRenvPackageSourceMissing = (
   return emsg.errCode === "renvPackageSourceMissing";
 };
 
+export const isEvtErrRenvEnvironmentSetup = (
+  emsg: EventStreamMessageErrorCoded,
+): emsg is EventStreamMessageErrorCoded<renvSetupEvtErr> => {
+  return (
+    emsg.errCode === "renvPackageNotInstalledError" ||
+    emsg.errCode === "renvActionRequiredError"
+  );
+};
+
 export const isEvtErrRequirementsReadingFailed = (
   emsg: EventStreamMessageErrorCoded,
 ): emsg is EventStreamMessageErrorCoded<requirementsReadingEvtErr> => {

extensions/vscode/src/utils/errorTypes.ts

@@ -13,6 +13,8 @@ export type ErrorCode =
   | "renvPackageVersionMismatch"
   | "renvPackageSourceMissing"
   | "renvlockPackagesReadingError"
+  | "renvPackageNotInstalledError"
+  | "renvActionRequiredError"
   | "requirementsFileReadingError"
   | "deployedContentNotRunning"
   | "tomlValidationError"

extensions/vscode/src/utils/window.test.ts

@@ -0,0 +1,168 @@
+// Copyright (C) 2025 by Posit Software, PBC.
+
+import { describe, expect, beforeEach, test, vi } from "vitest";
+import { window } from "vscode";
+import {
+  showErrorMessageWithTroubleshoot,
+  showInformationMsg,
+  taskWithProgressMsg,
+  runTerminalCommand,
+} from "./window";
+
+const terminalMock = {
+  sendText: vi.fn(),
+  show: vi.fn(),
+  exitStatus: {
+    code: 0,
+  },
+};
+
+const cancelTokenMock = {
+  onCancellationRequested: vi.fn(),
+};
+
+vi.mock("vscode", () => {
+  // mock Disposable
+  const disposableMock = vi.fn();
+  disposableMock.prototype.dispose = vi.fn();
+
+  // mock window
+  const windowMock = {
+    showErrorMessage: vi.fn(),
+    showWarningMessage: vi.fn(),
+    showInformationMessage: vi.fn(),
+    withProgress: vi.fn().mockImplementation((_, progressCallback) => {
+      progressCallback(_, cancelTokenMock);
+    }),
+    createTerminal: vi.fn().mockImplementation(() => {
+      terminalMock.sendText = vi.fn();
+      terminalMock.show = vi.fn();
+      return terminalMock;
+    }),
+    onDidCloseTerminal: vi.fn().mockImplementation((fn) => {
+      setTimeout(() => fn(terminalMock), 100);
+      return new disposableMock();
+    }),
+  };
+
+  return {
+    Disposable: disposableMock,
+    window: windowMock,
+    ProgressLocation: {
+      SourceControl: 1,
+      Window: 10,
+      Notification: 15,
+    },
+  };
+});
+
+describe("Consumers of vscode window", () => {
+  beforeEach(() => {
+    terminalMock.exitStatus.code = 0;
+  });
+
+  test("showErrorMessageWithTroubleshoot", () => {
+    showErrorMessageWithTroubleshoot("Bad things happened");
+    expect(window.showErrorMessage).toHaveBeenCalledWith(
+      "Bad things happened. See [Troubleshooting docs](https://github.com/posit-dev/publisher/blob/main/docs/troubleshooting.md) for help.",
+    );
+
+    showErrorMessageWithTroubleshoot(
+      "Bad things happened.",
+      "one",
+      "two",
+      "three",
+    );
+    expect(window.showErrorMessage).toHaveBeenCalledWith(
+      "Bad things happened. See [Troubleshooting docs](https://github.com/posit-dev/publisher/blob/main/docs/troubleshooting.md) for help.",
+      "one",
+      "two",
+      "three",
+    );
+  });
+
+  test("showInformationMsg", () => {
+    showInformationMsg("Good thing happened");
+    expect(window.showInformationMessage).toHaveBeenCalledWith(
+      "Good thing happened",
+    );
+
+    showInformationMsg("Good thing happened", "one", "two", "three");
+    expect(window.showInformationMessage).toHaveBeenCalledWith(
+      "Good thing happened",
+      "one",
+      "two",
+      "three",
+    );
+  });
+
+  describe("taskWithProgressMsg", () => {
+    test("not cancellable", () => {
+      const taskMock = vi.fn();
+      taskWithProgressMsg(
+        "Running a task with a progress notification",
+        taskMock,
+      );
+      expect(window.withProgress).toHaveBeenCalledWith(
+        {
+          location: 15,
+          title: "Running a task with a progress notification",
+          cancellable: false,
+        },
+        expect.any(Function),
+      );
+      expect(taskMock).toHaveBeenCalled();
+      expect(cancelTokenMock.onCancellationRequested).not.toHaveBeenCalled();
+    });
+
+    test("cancellable", () => {
+      const taskMock = vi.fn();
+      taskWithProgressMsg(
+        "Running a task with a progress notification",
+        taskMock,
+        () => {},
+      );
+      expect(window.withProgress).toHaveBeenCalledWith(
+        {
+          location: 15,
+          title: "Running a task with a progress notification",
+          cancellable: true,
+        },
+        expect.any(Function),
+      );
+      // Cancel listener is registered
+      expect(taskMock).toHaveBeenCalled();
+      expect(cancelTokenMock.onCancellationRequested).toHaveBeenCalled();
+    });
+  });
+
+  describe("runTerminalCommand", () => {
+    test("showing the terminal", async () => {
+      await runTerminalCommand("stat somefile.txt", true);
+      expect(terminalMock.sendText).toHaveBeenCalledWith("stat somefile.txt");
+      expect(terminalMock.show).toHaveBeenCalled();
+      // For terminals that we open, we don't track close events
+      expect(window.onDidCloseTerminal).not.toHaveBeenCalled();
+    });
+
+    test("NOT showing the terminal", async () => {
+      await runTerminalCommand("stat somefile.txt");
+      expect(terminalMock.sendText).toHaveBeenCalledWith("stat somefile.txt");
+      // For terminals that we DO NOT open, we DO track close events
+      expect(terminalMock.show).not.toHaveBeenCalled();
+      expect(window.onDidCloseTerminal).toHaveBeenCalled();
+    });
+
+    test("catch non zero exit status", async () => {
+      terminalMock.exitStatus.code = 1;
+      try {
+        await runTerminalCommand("stat somefile.txt");
+      } catch (_) {
+        expect(terminalMock.sendText).toHaveBeenCalledWith("stat somefile.txt");
+        // For terminals that we DO NOT open, we DO track close events
+        expect(terminalMock.show).not.toHaveBeenCalled();
+        expect(window.onDidCloseTerminal).toHaveBeenCalled();
+      }
+    });
+  });
+});

extensions/vscode/src/utils/window.ts

@@ -1,6 +1,6 @@
 // Copyright (C) 2025 by Posit Software, PBC.
 
-import { window } from "vscode";
+import { window, ProgressLocation, Progress, CancellationToken } from "vscode";
 
 export function showErrorMessageWithTroubleshoot(
   message: string,
@@ -14,3 +14,62 @@ export function showErrorMessageWithTroubleshoot(
     " See [Troubleshooting docs](https://github.com/posit-dev/publisher/blob/main/docs/troubleshooting.md) for help.";
   return window.showErrorMessage(msg, ...items);
 }
+
+export function showInformationMsg(msg: string, ...items: string[]) {
+  return window.showInformationMessage(msg, ...items);
+}
+
+type taskFunc = <T>(p: Progress<T>, t: CancellationToken) => Promise<void>;
+const progressCallbackHandlerFactory =
+  (task: taskFunc, onCancel?: () => void): taskFunc =>
+  (progress, token) => {
+    if (onCancel) {
+      token.onCancellationRequested(() => {
+        onCancel();
+      });
+    }
+    return task(progress, token);
+  };
+
+export function taskWithProgressMsg(
+  msg: string,
+  task: taskFunc,
+  onCancel?: () => void,
+) {
+  return window.withProgress(
+    {
+      location: ProgressLocation.Notification,
+      title: msg,
+      cancellable: onCancel !== undefined,
+    },
+    progressCallbackHandlerFactory(task, onCancel),
+  );
+}
+
+export function runTerminalCommand(
+  cmd: string,
+  show: boolean = false,
+): Promise<void> {
+  const term = window.createTerminal();
+  term.sendText(cmd);
+
+  // If terminal is shown, there is no need to track exit status for it
+  // everything will be visible on it.
+  if (show) {
+    term.show();
+    return Promise.resolve();
+  }
+
+  return new Promise((resolve, reject) => {
+    const disposeToken = window.onDidCloseTerminal((closedTerminal) => {
+      if (closedTerminal === term) {
+        disposeToken.dispose();
+        if (term.exitStatus && term.exitStatus.code === 0) {
+          resolve();
+        } else {
+          reject();
+        }
+      }
+    });
+  });
+}