@vellumai/assistant 0.12.2-staging.1 → 0.12.2-staging.3

package/src/runtime/routes/__tests__/apps-refresh-route.test.ts

@@ -5,7 +5,7 @@
  * implementations unless this file's tests are running.
  */
 
-import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { mkdirSync, rmSync, utimesSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import {
@@ -33,6 +33,9 @@ const realCompiler = { ...(await import("../../../bundler/app-compiler.js")) };
 const realNotify = {
   ...(await import("../../../daemon/app-change-notify.js")),
 };
+const realPinStore = {
+  ...(await import("../../../apps/app-pin-store.js")),
+};
 
 const compileApp = mock(
   async (
@@ -70,6 +73,16 @@ mock.module("../../../daemon/app-change-notify.js", () => ({
   },
 }));
 
+mock.module("../../../apps/app-pin-store.js", () => ({
+  ...realPinStore,
+  listAppPins: () => {
+    if (!mockActive) {
+      return realPinStore.listAppPins();
+    }
+    return [];
+  },
+}));
+
 const { createApp } = await import("../../../apps/app-store.js");
 const { getWorkspacePluginsDir } = await import("../../../util/platform.js");
 const { ROUTES } = await import("../app-management-routes.js");
@@ -83,6 +96,7 @@ function findHandler(operationId: string) {
 }
 
 const handleRefreshApp = findHandler("apps_refresh");
+const handleListApps = findHandler("apps_list");
 
 let workspaceDir: string;
 let previousWorkspaceDir: string | undefined;
@@ -142,6 +156,30 @@ describe("apps_refresh route", () => {
     });
   });
 
+  test("advances the workspace app list revision when compiled output changes", async () => {
+    const created = createApp({
+      name: "Budget",
+      schemaJson: "{}",
+      htmlDefinition: "<h1>Budget</h1>",
+    });
+    const builtAt = Math.ceil(created.updatedAt) + 1_000;
+    compileApp.mockImplementationOnce(async (appDir) => {
+      const distDir = join(appDir, "dist");
+      mkdirSync(distDir, { recursive: true });
+      utimesSync(distDir, new Date(builtAt), new Date(builtAt));
+      return { ok: true, errors: [], warnings: [], durationMs: 11 };
+    });
+
+    await handleRefreshApp({ pathParams: { id: created.id } });
+    const listed = (await handleListApps({})) as {
+      apps: Array<{ id: string; updatedAt: number }>;
+    };
+
+    expect(listed.apps.find((app) => app.id === created.id)?.updatedAt).toBe(
+      builtAt,
+    );
+  });
+
   test("compiles a plugin app in place", async () => {
     const pluginName = `charts-${Math.random().toString(36).slice(2, 8)}`;
     const pluginDir = join(getWorkspacePluginsDir(), pluginName);
@@ -157,9 +195,7 @@ describe("apps_refresh route", () => {
       pathParams: { id: pluginAppId },
     });
 
-    expect(compileApp).toHaveBeenCalledWith(
-      join(pluginDir, "apps", "viewer"),
-    );
+    expect(compileApp).toHaveBeenCalledWith(join(pluginDir, "apps", "viewer"));
     expect(notifyAppSurfacesChanged).toHaveBeenCalledWith(pluginAppId, {
       fileChange: true,
     });
@@ -171,6 +207,40 @@ describe("apps_refresh route", () => {
     });
   });
 
+  test("advances the plugin app list revision when compiled output changes", async () => {
+    const pluginName = `charts-${Math.random().toString(36).slice(2, 8)}`;
+    const appDir = join(getWorkspacePluginsDir(), pluginName, "apps", "viewer");
+    mkdirSync(appDir, { recursive: true });
+    writeFileSync(
+      join(getWorkspacePluginsDir(), pluginName, "package.json"),
+      JSON.stringify({ name: pluginName, version: "1.0.0" }),
+    );
+    const pluginAppId = `plugins~${pluginName}~viewer`;
+    const before = (await handleListApps({})) as {
+      apps: Array<{ id: string; updatedAt: number }>;
+    };
+    const previousRevision = before.apps.find(
+      (app) => app.id === pluginAppId,
+    )?.updatedAt;
+    expect(previousRevision).toBeDefined();
+    const builtAt = Math.ceil(previousRevision!) + 1_000;
+    compileApp.mockImplementationOnce(async (sourceDir) => {
+      const distDir = join(sourceDir, "dist");
+      mkdirSync(distDir, { recursive: true });
+      utimesSync(distDir, new Date(builtAt), new Date(builtAt));
+      return { ok: true, errors: [], warnings: [], durationMs: 11 };
+    });
+
+    await handleRefreshApp({ pathParams: { id: pluginAppId } });
+    const after = (await handleListApps({})) as {
+      apps: Array<{ id: string; updatedAt: number }>;
+    };
+
+    expect(after.apps.find((app) => app.id === pluginAppId)?.updatedAt).toBe(
+      builtAt,
+    );
+  });
+
   test("returns compile errors without throwing", async () => {
     const created = createApp({
       name: "Budget",

package/src/runtime/routes/__tests__/plugins-routes.test.ts

@@ -1239,8 +1239,12 @@ describe("GET /v1/plugins/search", () => {
 
 async function invokeUninstall(
   args: RouteHandlerArgs = {},
-): Promise<{ name: string; target: string }> {
-  return (await uninstallHandler(args)) as { name: string; target: string };
+): Promise<{ name: string; target: string; warnings?: string[] }> {
+  return (await uninstallHandler(args)) as {
+    name: string;
+    target: string;
+    warnings?: string[];
+  };
 }
 
 describe("DELETE /v1/plugins/:name", () => {
@@ -1278,6 +1282,22 @@ describe("DELETE /v1/plugins/:name", () => {
     expectPluginsListBroadcast();
   });
 
+  test("returns non-fatal cleanup warnings from the shared uninstall", async () => {
+    uninstallSpy.mockImplementation(async (opts) => ({
+      name: opts.name,
+      target: `/workspace/.vellum/plugins/${opts.name}`,
+      warnings: ["plugin.uninstall.mcp_oauth_credentials_unchecked"],
+    }));
+
+    const result = await invokeUninstall({
+      pathParams: { name: "simple-memory" },
+    });
+
+    expect(result.warnings).toEqual([
+      "plugin.uninstall.mcp_oauth_credentials_unchecked",
+    ]);
+  });
+
   test("threads x-vellum-client-id into the published event's originClientId", async () => {
     uninstallSpy.mockImplementation(async (opts) => ({
       name: opts.name,
@@ -2759,7 +2779,9 @@ describe("POST /v1/plugins/:name/disable", () => {
       toggleResult(name, "disable"),
     );
 
-    const result = await invokeDisable({ pathParams: { name: "simple-memory" } });
+    const result = await invokeDisable({
+      pathParams: { name: "simple-memory" },
+    });
 
     expect(result).toEqual({ ok: true });
     expect(disablePluginSpy.mock.calls[0]?.[0]).toBe("simple-memory");

package/src/runtime/routes/acp-claude-auth-routes.ts

@@ -18,7 +18,7 @@
  *   has landed.
  * POST /v1/acp/claude/auth/exchange — complete a manual/cloud flow: accept the
  *   pasted `code#state` (or a raw code + state), exchange it, and store the
- *   Claude OAuth token.
+ *   Claude OAuth token set (access token plus any refresh token and expiry).
  *
  * `handleStartAuth` picks loopback vs. manual: a containerized host, or a client
  * that sets `preferManual` because its browser can't reach the daemon's
@@ -126,7 +126,11 @@ async function handleStartLocalAuth(): Promise<StartResponse> {
   // can react. Runs in the background — the web client opens `authorize_url`.
   void flow.completion
     .then(async (result) => {
-      await storeAcpClaudeToken(result.tokens.accessToken);
+      await storeAcpClaudeToken({
+        accessToken: result.tokens.accessToken,
+        refreshToken: result.tokens.refreshToken,
+        expiresIn: result.tokens.expiresIn,
+      });
       pendingFlows.mark(flow.state, "connected");
       log.info("ACP Claude local OAuth flow connected");
     })
@@ -216,7 +220,11 @@ async function handleExchange(args: RouteHandlerArgs): Promise<{ ok: true }> {
       pending.codeVerifier,
       state,
     );
-    await storeAcpClaudeToken(result.tokens.accessToken);
+    await storeAcpClaudeToken({
+      accessToken: result.tokens.accessToken,
+      refreshToken: result.tokens.refreshToken,
+      expiresIn: result.tokens.expiresIn,
+    });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     pendingFlows.mark(state, "error", { error: message });

package/src/runtime/routes/app-management-routes.ts

@@ -181,7 +181,7 @@ function workspaceAppItem(a: AppDefinition): AppListItem {
     description: a.description,
     icon: a.icon,
     createdAt: a.createdAt,
-    updatedAt: a.updatedAt,
+    updatedAt: appContentUpdatedAt(getAppDirPath(a.id), a.updatedAt),
     version: a.version ?? "1.0.0",
     contentId: computeContentId(a.name),
     origin: "workspace",
@@ -203,13 +203,28 @@ function pluginAppItem(app: EnumeratedApp): AppListItem {
     id: app.id,
     name: app.name,
     createdAt: mtime,
-    updatedAt: mtime,
+    updatedAt: appContentUpdatedAt(app.sourcePath, mtime),
     version: "1.0.0",
     contentId: computeContentId(app.name),
     origin: `plugin:${pluginName}`,
   };
 }
 
+/** The newest persisted metadata or compiled-output revision for an app. */
+function appContentUpdatedAt(
+  sourcePath: string,
+  metadataUpdatedAt: number,
+): number {
+  try {
+    return Math.max(
+      metadataUpdatedAt,
+      statSync(join(sourcePath, "dist")).mtimeMs,
+    );
+  } catch {
+    return metadataUpdatedAt;
+  }
+}
+
 function getAppDataResult(
   method: string,
   appId: string,

package/src/runtime/routes/browser-context.ts

@@ -0,0 +1,39 @@
+import { resolveTurnClientOs } from "../../daemon/conversation-client-surface.js";
+import { findConversation } from "../../daemon/conversation-registry.js";
+import type { ToolContext } from "../../tools/types.js";
+import { resolveActorPrincipalIdForLocalGuardian } from "../local-actor-identity.js";
+
+export function browserCliConversationKey(sessionId: string): string {
+  return `browser-cli:${sessionId}`;
+}
+
+export async function resolveBrowserContext(
+  conversationId: string | undefined,
+  sessionId: string,
+  headers: Record<string, string>,
+  abortSignal?: AbortSignal,
+): Promise<ToolContext> {
+  const conversation = conversationId
+    ? findConversation(conversationId)
+    : undefined;
+  const actor = await resolveActorPrincipalIdForLocalGuardian(
+    conversation?.getTurnActorPrincipalId() ??
+      headers["x-vellum-actor-principal-id"]?.trim(),
+  );
+  const signals = [abortSignal, conversation?.abortController?.signal].filter(
+    (signal): signal is AbortSignal => signal !== undefined,
+  );
+  return {
+    workingDir: process.cwd(),
+    conversationId: conversation
+      ? conversationId!
+      : browserCliConversationKey(sessionId),
+    trustClass: conversation?.trustContext?.trustClass ?? "unknown",
+    transportInterface: conversation?.transportInterface,
+    clientOs: conversation
+      ? resolveTurnClientOs(conversation).clientOs
+      : undefined,
+    sourceActorPrincipalId: actor,
+    signal: signals.length ? AbortSignal.any(signals) : undefined,
+  };
+}

package/src/runtime/routes/browser-routes.ts

@@ -16,10 +16,12 @@ import {
   BROWSER_OPERATIONS,
   type BrowserOperation,
 } from "../../browser/types.js";
-import { findConversation } from "../../daemon/conversation-registry.js";
+import { shouldUseVirtualDesktopBrowser } from "../../browser/virtual-desktop-target.js";
+import { executeDesktopBrowserOperation } from "../../desktop/desktop-browser-operations.js";
 import type { ContentBlock } from "../../providers/types.js";
 import { LOCAL_PRINCIPALS } from "../auth/route-policy.js";
-import { resolveActorPrincipalIdForLocalGuardian } from "../local-actor-identity.js";
+import { resolveBrowserContext } from "./browser-context.js";
+export { browserCliConversationKey } from "./browser-context.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
 // ── Param validation ─────────────────────────────────────────────────
@@ -29,18 +31,9 @@ const BrowserExecuteParams = z.object({
   input: z.record(z.string(), z.unknown()).default({}),
   sessionId: z.string().min(1).default("default"),
   conversationId: z.string().min(1).optional(),
+  desktop: z.boolean().optional(),
 });
 
-// ── Conversation key ─────────────────────────────────────────────────
-
-/**
- * Build a deterministic conversation key from a session ID.
- * All CLI browser calls with the same session share browser state.
- */
-export function browserCliConversationKey(sessionId: string): string {
-  return `browser-cli:${sessionId}`;
-}
-
 // ── Screenshot extraction ────────────────────────────────────────────
 
 /**
@@ -70,45 +63,21 @@ function extractScreenshots(
 async function handleBrowserExecute({
   body = {},
   headers = {},
+  abortSignal,
 }: RouteHandlerArgs) {
-  const { operation, input, sessionId, conversationId } =
+  const { operation, input, sessionId, conversationId, desktop } =
     BrowserExecuteParams.parse(body);
 
-  // When the caller passes a live conversation ID (e.g. from
-  // __CONVERSATION_ID in a nested bash invocation), reuse that
-  // conversation's trust context and transport interface.
-  const conversation = conversationId
-    ? findConversation(conversationId)
-    : undefined;
-
-  const resolvedConversationId = conversation
-    ? conversationId!
-    : browserCliConversationKey(sessionId);
-
-  // Actor principal lets host-browser routing enforce same-actor ownership.
-  // A live conversation's turn actor owns the request (e.g. a nested-bash
-  // browser call inherits the conversation's actor), so it wins over the
-  // request header — which over IPC may carry a synthetic local-guardian id
-  // injected for header-less local callers. Resolve through the local-guardian
-  // translation so the value matches the actorPrincipalId host_browser clients
-  // register with (dev-bypass otherwise mismatches).
-  const headerActor =
-    headers["x-vellum-actor-principal-id"]?.trim() || undefined;
-  const sourceActorPrincipalId = await resolveActorPrincipalIdForLocalGuardian(
-    conversation?.getTurnActorPrincipalId() ?? headerActor,
-  );
-
-  const result = await executeBrowserOperation(
-    operation as BrowserOperation,
-    input,
-    {
-      workingDir: process.cwd(),
-      conversationId: resolvedConversationId,
-      trustClass: conversation?.trustContext?.trustClass ?? "unknown",
-      transportInterface: conversation?.transportInterface,
-      sourceActorPrincipalId,
-    },
+  const context = await resolveBrowserContext(
+    conversationId,
+    sessionId,
+    headers,
+    abortSignal,
   );
+  const execute = shouldUseVirtualDesktopBrowser(desktop, input, context)
+    ? executeDesktopBrowserOperation
+    : executeBrowserOperation;
+  const result = await execute(operation as BrowserOperation, input, context);
 
   const screenshots = extractScreenshots(result.contentBlocks);
 

package/src/runtime/routes/browser-tabs-routes.ts

@@ -2,22 +2,23 @@
  * Routes for browser tab management commands.
  *
  * Exposes `browser_tabs` so CLI commands can list, create, select, and
- * close browser tabs via the Chrome extension backend.
+ * close browser tabs in the Chrome extension or streamed desktop browser.
  */
 
 import { z } from "zod";
 
-import { findConversation } from "../../daemon/conversation-registry.js";
+import { shouldUseVirtualDesktopBrowser } from "../../browser/virtual-desktop-target.js";
 import { HostBrowserProxy } from "../../daemon/host-browser-proxy.js";
+import { executeDesktopBrowserTabs } from "../../desktop/desktop-browser-operations.js";
+import { normalizeBrowserMode } from "../../tools/browser/browser-mode.js";
 import { getCdpClient } from "../../tools/browser/cdp-client/factory.js";
 import {
   clearPinnedTab,
   clearPinnedTabByTabId,
   setPinnedTab,
 } from "../../tools/browser/pinned-tabs.js";
-import type { ToolContext } from "../../tools/types.js";
 import { LOCAL_PRINCIPALS } from "../auth/route-policy.js";
-import { browserCliConversationKey } from "./browser-routes.js";
+import { resolveBrowserContext } from "./browser-context.js";
 import { BadRequestError } from "./errors.js";
 import { parseBody } from "./parse-body.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
@@ -26,6 +27,8 @@ const BrowserTabsParams = z.object({
   command: z.enum(["list", "select", "new", "close"]),
   sessionId: z.string().min(1).default("default"),
   conversationId: z.string().min(1).optional(),
+  desktop: z.boolean().optional(),
+  browserMode: z.string().optional(),
   tabId: z.number().optional(),
   url: z.string().optional(),
   // Route tab operations to a specific extension client in multi-client
@@ -33,33 +36,73 @@ const BrowserTabsParams = z.object({
   targetClientId: z.string().min(1).optional(),
 });
 
-async function handleBrowserTabs({ body = {} }: RouteHandlerArgs) {
-  const { command, sessionId, conversationId, tabId, url, targetClientId } =
-    parseBody(BrowserTabsParams, body);
-
-  const conversation = conversationId
-    ? findConversation(conversationId)
-    : undefined;
-  const resolvedConversationId = conversation
-    ? conversationId!
-    : browserCliConversationKey(sessionId);
-
-  const context = {
-    workingDir: process.cwd(),
-    conversationId: resolvedConversationId,
-    trustClass: conversation?.trustContext?.trustClass ?? "unknown",
-    transportInterface: conversation?.transportInterface,
-  } as unknown as ToolContext;
+async function handleBrowserTabs({
+  body = {},
+  headers = {},
+  abortSignal,
+}: RouteHandlerArgs) {
+  const {
+    command,
+    sessionId,
+    conversationId,
+    tabId,
+    url,
+    targetClientId,
+    desktop,
+    browserMode,
+  } = parseBody(BrowserTabsParams, body);
 
-  const cdpOptions = { mode: "extension" as const, targetClientId };
+  const context = await resolveBrowserContext(
+    conversationId,
+    sessionId,
+    headers,
+    abortSignal,
+  );
+  const resolvedConversationId = context.conversationId;
+  const mode = normalizeBrowserMode(browserMode);
+  if ("error" in mode) {
+    throw new BadRequestError(mode.error);
+  }
+  if (
+    shouldUseVirtualDesktopBrowser(
+      desktop,
+      { browser_mode: browserMode, target_client_id: targetClientId },
+      context,
+    )
+  ) {
+    if (
+      targetClientId ||
+      (mode.mode !== "auto" && mode.mode !== "cdp-inspect")
+    ) {
+      throw new BadRequestError(
+        "--virtual-desktop cannot target a personal browser client",
+      );
+    }
+    const result = await executeDesktopBrowserTabs(
+      { command, tabId, url },
+      context,
+    );
+    if (result.isError) {
+      throw new BadRequestError(result.content);
+    }
+    return JSON.parse(result.content);
+  }
 
-  // Every tabs command pins extension mode. Absorb a brief extension SSE
-  // reconnect blip so a flapping connection doesn't surface as a hard
-  // "no Chrome Extension connected" error.
-  await HostBrowserProxy.instance.waitForExtensionClient(
-    context.sourceActorPrincipalId,
+  const cdpOptions = {
+    mode:
+      targetClientId || mode.mode === "auto"
+        ? ("extension" as const)
+        : mode.mode,
     targetClientId,
-  );
+  };
+
+  // Absorb brief reconnects before dispatching to the extension.
+  if (cdpOptions.mode === "extension") {
+    await HostBrowserProxy.instance.waitForExtensionClient(
+      context.sourceActorPrincipalId,
+      targetClientId,
+    );
+  }
 
   if (command === "list") {
     const cdp = getCdpClient(context, cdpOptions);
@@ -185,7 +228,7 @@ export const ROUTES: RouteDefinition[] = [
     handler: handleBrowserTabs,
     summary: "Manage browser tabs",
     description:
-      "List, create, select, or close browser tabs via the Chrome extension backend.",
+      "List, create, select, or close browser tabs in the Chrome extension or streamed desktop browser.",
     tags: ["browser"],
     requestBody: BrowserTabsParams,
     responseBody: z.object({

package/src/runtime/routes/credential-routes.ts

@@ -34,7 +34,6 @@ import { credentialKey } from "../../security/credential-key.js";
 import {
   deleteSecureKeyAsync,
   getActiveBackendInfoAsync,
-  getSecureKeyAsync,
   getSecureKeyResultAsync,
 } from "../../security/secure-keys.js";
 import {
@@ -561,9 +560,7 @@ async function handleCredentialsDelete({ body }: RouteHandlerArgs) {
 
   const key = credentialKey(service, field);
   const affectedConnections = assertCredentialNotInUse(key, force === true);
-  const existing = await getSecureKeyAsync(key);
-  const deleteResult =
-    existing != null ? await deleteSecureKeyAsync(key) : "not-found";
+  const deleteResult = await deleteSecureKeyAsync(key);
 
   if (deleteResult === "error") {
     throw new InternalError(

package/src/runtime/routes/desktop-setup-routes.test.ts

@@ -14,6 +14,7 @@ import { ROUTES } from "./desktop-setup-routes.js";
 import { NotFoundError } from "./errors.js";
 
 const originalContainerized = process.env.IS_CONTAINERIZED;
+const originalPlatform = process.env.IS_PLATFORM;
 const status = spyOn(desktopDependencyInstaller, "getStatus");
 const start = spyOn(desktopDependencyInstaller, "start");
 
@@ -24,6 +25,7 @@ afterAll(() => {
 
 beforeEach(() => {
   process.env.IS_CONTAINERIZED = "true";
+  process.env.IS_PLATFORM = "true";
   status.mockReturnValue({ state: "required" });
   start.mockReturnValue({ state: "installing", stage: "packages" });
 });
@@ -34,6 +36,11 @@ afterEach(() => {
   } else {
     process.env.IS_CONTAINERIZED = originalContainerized;
   }
+  if (originalPlatform === undefined) {
+    delete process.env.IS_PLATFORM;
+  } else {
+    process.env.IS_PLATFORM = originalPlatform;
+  }
   setOverridesForTesting({});
   status.mockClear();
   start.mockClear();
@@ -60,7 +67,15 @@ describe("desktop setup route feature gate", () => {
       expect(start).not.toHaveBeenCalled();
     });
 
-    test(`${route.method} serves setup only with the flag enabled in a container`, () => {
+    test(`${route.method} rejects self-hosted Docker assistants without inspecting or installing dependencies`, () => {
+      process.env.IS_PLATFORM = "false";
+      setOverridesForTesting({ "assistant-desktop": true });
+      expect(() => route.handler({})).toThrow(NotFoundError);
+      expect(status).not.toHaveBeenCalled();
+      expect(start).not.toHaveBeenCalled();
+    });
+
+    test(`${route.method} serves setup only for enabled platform containers`, () => {
       setOverridesForTesting({ "assistant-desktop": true });
       expect(route.handler({})).toEqual(
         route.method === "GET"

package/src/runtime/routes/desktop-setup-routes.ts

@@ -2,7 +2,7 @@ import { z } from "zod";
 
 import { getConfig } from "../../config/loader.js";
 import { desktopDependencyInstaller } from "../../desktop/desktop-dependencies.js";
-import { isAssistantDesktopEnabled } from "../../desktop/desktop-feature.js";
+import { isVirtualDesktopEnabled } from "../../desktop/virtual-desktop-feature.js";
 import { GATEWAY_PRINCIPALS } from "../auth/route-policy.js";
 import { NotFoundError } from "./errors.js";
 import type { RouteDefinition } from "./types.js";
@@ -19,8 +19,10 @@ export const ROUTES: RouteDefinition[] = ["GET", "POST"].map((method) => ({
   method,
   policy: { requiredScopes: [], allowedPrincipalTypes: GATEWAY_PRINCIPALS },
   handler: () => {
-    if (!isAssistantDesktopEnabled(getConfig())) {
-      throw new NotFoundError("Desktop is not available on this assistant");
+    if (!isVirtualDesktopEnabled(getConfig())) {
+      throw new NotFoundError(
+        "Virtual desktop is available only on enabled platform-hosted assistants",
+      );
     }
     return method === "GET"
       ? desktopDependencyInstaller.getStatus()
@@ -28,8 +30,8 @@ export const ROUTES: RouteDefinition[] = ["GET", "POST"].map((method) => ({
   },
   summary:
     method === "GET"
-      ? "Get desktop setup status"
-      : "Install desktop components",
+      ? "Get virtual desktop setup status"
+      : "Install virtual desktop components",
   tags: ["desktop"],
   responseBody: statusSchema,
 }));