Generate process containers with Wave (#122)

---------

Co-authored-by: Ben Sherman <[email protected]>

Author: MythicalFish

src/constants.ts

@@ -1,3 +1,4 @@
 export const SEQERA_PLATFORM_URL = `https://cloud.seqera.io`;
 export const SEQERA_API_URL = `${SEQERA_PLATFORM_URL}/api`;
+export const SEQERA_HUB_API_URL = `https://hub.seqera.io`;
 export const SEQERA_INTERN_API_URL = `https://intern.seqera.io`;

src/webview/WebviewProvider/index.ts

@@ -11,7 +11,8 @@ import {
   fetchPlatformData,
   fetchRuns,
   getRepoInfo,
-  queryWorkspace
+  queryWorkspace,
+  getContainer
 } from "./lib";
 import { AuthProvider, getAccessToken } from "../../auth";
 import { jwtExpired } from "../../auth/AuthProvider/utils/jwt";
@@ -32,11 +33,10 @@ class WebviewProvider implements vscode.WebviewViewProvider {
   public async resolveWebviewView(view: vscode.WebviewView): Promise<void> {
     this._authProvider?.setWebview(view.webview);
     this.initHTML(view);
-    await sleep(100); // Wait for the app to mount
-    await this.initViewData();
 
     view.webview.onDidReceiveMessage((message) => {
       const { command, workspaceId } = message;
+      console.log("🟠 onDidReceiveMessage", message);
       switch (command) {
         case "openFile":
           this.openFile(message.path, message.line);
@@ -75,13 +75,19 @@ class WebviewProvider implements vscode.WebviewViewProvider {
         case "createTest":
           this.createTest(message.filePath);
           break;
+        case "getContainer":
+          this.getContainer(message.filePath);
+          break;
       }
     });
 
     view.onDidChangeVisibility(() => {
       if (!view.visible) return;
       this.initViewData();
     });
+
+    await sleep(100); // Wait for the app to mount
+    await this.initViewData();
   }
 
   private async login() {
@@ -148,6 +154,7 @@ class WebviewProvider implements vscode.WebviewViewProvider {
 
   public async initViewData(refresh?: boolean) {
     const { viewID, _context, _currentView: view } = this;
+    console.log("🟠 initViewData", viewID);
     if (!view) return;
     if (viewID === "seqeraCloud") {
       this.getRepoInfo();
@@ -172,7 +179,6 @@ class WebviewProvider implements vscode.WebviewViewProvider {
 
   private async createTest(filePath: string) {
     const accessToken = await getAccessToken(this._context);
-    if (!accessToken) return false;
 
     try {
       const created = await createTest(filePath, accessToken);
@@ -183,6 +189,27 @@ class WebviewProvider implements vscode.WebviewViewProvider {
     }
   }
 
+  private async emitContainerCreated(filePath: string, successful: boolean) {
+    this._currentView?.webview.postMessage({
+      containerCreated: {
+        filePath,
+        successful
+      }
+    });
+  }
+
+  private async getContainer(filePath: string) {
+    const accessToken = await getAccessToken(this._context);
+
+    try {
+      const created = await getContainer(filePath, accessToken);
+      this.emitContainerCreated(filePath, created);
+    } catch (error) {
+      console.log("🟠 Container creation failed", error);
+      this.emitContainerCreated(filePath, false);
+    }
+  }
+
   private async openFile(filePath: string, line: number) {
     const doc = await vscode.workspace.openTextDocument(filePath);
     await vscode.window.showTextDocument(doc, {

src/webview/WebviewProvider/lib/platform/utils/createTest/fetchContent.ts

@@ -1,12 +1,14 @@
 import { SEQERA_INTERN_API_URL } from "../../../../../../constants";
-import { systemPrompt } from "./prompt";
+import { systemPrompt as defaultSystemPrompt } from "./prompt";
 
 async function fetchContent(
   prompt: string,
   token: string,
-  onChunk?: (chunk: string) => void
+  onChunk?: (chunk: string) => void,
+  givenSystemPrompt?: string
 ): Promise<string> {
   try {
+    const systemPrompt = givenSystemPrompt || defaultSystemPrompt;
     const fullPrompt = `:::details\n\n${systemPrompt}\n\n${prompt}\n\n:::\n\n`;
     const url = `${SEQERA_INTERN_API_URL}/internal-ai/query`;
 

src/webview/WebviewProvider/lib/platform/utils/createTest/index.ts

@@ -15,7 +15,7 @@ function getTestPath(filePath: string): string {
   return path.join(testDir, baseName.replace(".nf", ".nf.test"));
 }
 
-async function createTest(filePath: string, token: string): Promise<boolean> {
+async function createTest(filePath: string, token = ""): Promise<boolean> {
   return vscode.window.withProgress(
     {
       location: vscode.ProgressLocation.Notification,
@@ -70,6 +70,7 @@ async function createTest(filePath: string, token: string): Promise<boolean> {
       } catch (error: any) {
         const isAuthError =
           error?.message?.includes("401") ||
+          error?.message?.includes("403") ||
           error?.message?.includes("Unauthorized");
 
         if (isAuthError) {

src/webview/WebviewProvider/lib/platform/utils/getContainer/generateRequirements.ts

@@ -0,0 +1,20 @@
+import fetchContent from "../createTest/fetchContent";
+import { getPrompt } from "./prompt";
+
+async function generateRequirements(
+  content: string,
+  token: string,
+  onChunk?: (chunk: string) => void
+): Promise<string> {
+  const prompt = getPrompt(content);
+
+  try {
+    const response = await fetchContent(prompt, token, onChunk);
+    return response;
+  } catch (error) {
+    console.error("🟠 Error generating requirements:", error);
+    throw error;
+  }
+}
+
+export default generateRequirements;

src/webview/WebviewProvider/lib/platform/utils/getContainer/index.ts

@@ -0,0 +1,104 @@
+import * as vscode from "vscode";
+import * as fs from "fs";
+import generateRequirements from "./generateRequirements";
+import { startBuild } from "./startBuild";
+
+async function getContainer(filePath: string, token = ""): Promise<boolean> {
+  return vscode.window.withProgress(
+    {
+      location: vscode.ProgressLocation.Notification,
+      cancellable: false
+    },
+    async (progress) => {
+      try {
+        // Open the original file
+        const originalFilePath = vscode.Uri.file(filePath);
+        await vscode.workspace.openTextDocument(originalFilePath);
+
+        const content = fs.readFileSync(filePath, "utf8");
+
+        // Find required packages
+        progress.report({ message: "Seqera AI: Finding required packages" });
+        const generatedContent = await generateRequirements(content, token);
+
+        // Start container build
+        progress.report({ message: "Wave: Starting container build" });
+        const buildResult = await startBuild(generatedContent);
+
+        if (buildResult.error) {
+          vscode.window.showErrorMessage(
+            `Wave: Failed to build container: ${buildResult.error}`
+          );
+          return false;
+        }
+
+        const { buildId, containerImage } = buildResult;
+
+        if (buildId) {
+          const buildUrl = `https://wave.seqera.io/view/builds/${buildId}`;
+          const openBuildAction = "See details";
+
+          if (containerImage) {
+            progress.report({ message: "Wave: Container built" });
+
+            // Show URL
+            await vscode.window.showInputBox({
+              value: containerImage,
+              ignoreFocusOut: true,
+              title: "Wave Image URL"
+            });
+
+            // Copy to clipboard
+            await vscode.env.clipboard.writeText(containerImage);
+
+            // Show success message
+            vscode.window
+              .showInformationMessage(
+                `Wave: Copied to clipboard`,
+                openBuildAction
+              )
+              .then((selection) => {
+                if (selection === openBuildAction) {
+                  vscode.env.openExternal(vscode.Uri.parse(buildUrl));
+                }
+              });
+          }
+        } else {
+          vscode.window.showErrorMessage("Wave: Failed to build container");
+          return false;
+        }
+
+        return true;
+      } catch (error: any) {
+        const isAuthError =
+          error?.message?.includes("401") ||
+          error?.message?.includes("403") ||
+          error?.message?.includes("Unauthorized");
+
+        if (isAuthError) {
+          return handleAuthError();
+        } else {
+          vscode.window.showErrorMessage(
+            `Wave: Failed to build container: ${error?.message}`
+          );
+          return false;
+        }
+      }
+    }
+  );
+}
+
+async function handleAuthError(): Promise<boolean> {
+  const loginAction = "Login to Seqera Cloud";
+  const result = await vscode.window.showInformationMessage(
+    "Authentication required to generate nf-test. Please login to continue.",
+    loginAction
+  );
+
+  if (result === loginAction) {
+    await vscode.commands.executeCommand("nextflow.seqera.login");
+  }
+  return false;
+}
+
+export default getContainer;

src/webview/WebviewProvider/lib/platform/utils/getContainer/prompt.ts

@@ -0,0 +1,12 @@
+export const systemPrompt = `You ONLY output pure CSV, nothing else. Do not include backticks or code blocks. You do not output any other text such as explanations, or anything else. You output pure CSV.`;
+
+export const getPrompt = (fileContents: string) => {
+  return `
+Analyze the following code, and determine which packages would be required to make a Wave container for it.
+Your response should be in the format of "channel::package=version,channel::package=version".
+For example: "bioconda::bcftools=1.2,pip:numpy==2.0.0rc1,bioconda::bioconductor-iranges=2.36.0"
+
+Here is the code:
+${fileContents}
+`;
+};

src/webview/WebviewProvider/lib/platform/utils/getContainer/startBuild.ts

@@ -0,0 +1,109 @@
+import { SEQERA_HUB_API_URL } from "../../../../../../constants";
+import type {
+  ImageType,
+  PackageResult,
+  Platform,
+  WaveBuild,
+  WaveResponse
+} from "./types";
+
+type StartBuildPayload = {
+  packages: {
+    type: "CONDA";
+    channels: string[];
+    entries: string[];
+  };
+  format?: string;
+  containerPlatform?: string;
+};
+
+function parsePackagesString(packagesString: string): PackageResult[] {
+  return packagesString.split(",").map((pkg) => {
+    const [spec, version] = pkg.split("=");
+    const [channel, name] = spec.split("::");
+
+    return {
+      name,
+      source: channel === "pip" ? "pip" : "conda",
+      selected_version: version
+    };
+  });
+}
+
+/**
+ * Starts a container build process with the specified packages and configuration
+ * @param packagesString - String of packages in format "channel::package=version,channel::package=version"
+ * @param imageType - Type of container image to build (e.g. "singularity")
+ * @param selectedPlatform - Target platform for the container
+ * @returns Promise resolving to the build information or error
+ */
+export async function startBuild(
+  packagesString: string,
+  imageType?: ImageType,
+  selectedPlatform?: Platform
+): Promise<WaveBuild> {
+  const packages = parsePackagesString(packagesString);
+
+  if (packages.length === 0) {
+    throw new Error("No packages added to container");
+  }
+
+  console.log("🟢 Starting container build with packages:", packages);
+
+  const url = `${SEQERA_HUB_API_URL}/container`;
+
+  // Collect all required channels, including default ones
+  const channels = new Set(["conda-forge", "bioconda"]);
+  packages.forEach((p) => {
+    if (p.channel && !channels.has(p.channel)) {
+      channels.add(p.channel);
+    }
+  });
+
+  const payload: StartBuildPayload = {
+    packages: {
+      type: "CONDA",
+      channels: Array.from(channels),
+      entries: packages.map(
+        (p) => `${p.name}${p.selected_version ? `=${p.selected_version}` : ""}`
+      )
+    }
+  };
+
+  if (imageType === "singularity") {
+    payload.format = "sif";
+  }
+
+  if (selectedPlatform === "linux/arm64") {
+    payload.containerPlatform = "arm64";
+  }
+
+  console.log("🟢 Build payload:", payload);
+
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(payload)
+    });
+
+    const build = (await response.json()) as WaveResponse;
+
+    if (response.ok) {
+      console.log("🟢 Container built:", build);
+      return build;
+    }
+
+    console.log(
+      "🟠 Build request failed:",
+      response.status,
+      response.statusText
+    );
+    return { buildId: build.buildId, error: response.statusText };
+  } catch (error) {
+    console.error("🟠 Error starting build:", error);
+    throw new Error(
+      `${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}