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

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/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,
 }));

package/src/runtime/routes/mcp-auth-routes.ts

@@ -17,7 +17,12 @@ import { z } from "zod";
 import type { McpServerConfig } from "../../config/schemas/mcp.js";
 import { estimateToolDefinitionTokens } from "../../context/token-estimator.js";
 import { reloadMcpServers } from "../../daemon/mcp-reload-service.js";
-import { McpClient } from "../../mcp/client.js";
+import {
+  mcpOAuthCredentialKey,
+  resolveMcpOAuthCredentialTarget,
+  workspaceMcpOAuthCredentialTarget,
+} from "../../mcp/credential-target.js";
+import { readEffectiveMcpConfig } from "../../mcp/effective-config.js";
 import { getMcpServerManager } from "../../mcp/manager.js";
 import { orchestrateMcpOAuthConnect } from "../../mcp/mcp-auth-orchestrator.js";
 import { getMcpAuthState } from "../../mcp/mcp-auth-state.js";
@@ -74,9 +79,7 @@ function persistWorkspaceMcpConfig(config: {
   try {
     saveWorkspaceMcpConfig(config);
   } catch (err) {
-    throw new InternalError(
-      err instanceof Error ? err.message : String(err),
-    );
+    throw new InternalError(err instanceof Error ? err.message : String(err));
   }
 }
 
@@ -91,8 +94,9 @@ async function handleMcpAuthStart({
 }> {
   const { serverId } = parseBody(McpServerIdParams, body);
 
-  const servers = loadWorkspaceMcpConfig().servers;
-  const serverConfig = servers[serverId];
+  const serverConfig = readEffectiveMcpConfig(loadWorkspaceMcpConfig()).servers[
+    serverId
+  ];
 
   if (!serverConfig) {
     throw new BadRequestError(`MCP server "${serverId}" not configured`);
@@ -105,10 +109,29 @@ async function handleMcpAuthStart({
     );
   }
 
+  const credentialTarget = resolveMcpOAuthCredentialTarget(
+    serverId,
+    serverConfig,
+  );
+  if (!credentialTarget) {
+    throw new BadRequestError(
+      `OAuth only supported for sse/streamable-http transports (server "${serverId}" uses ${transport.type})`,
+    );
+  }
+
+  try {
+    mcpOAuthCredentialKey(credentialTarget, "tokens");
+  } catch {
+    throw new BadRequestError(
+      `MCP server "${serverId}" has an invalid transport URL`,
+    );
+  }
+
   let result: { auth_url: string; already_authenticated?: boolean };
   try {
     result = await orchestrateMcpOAuthConnect({
       serverId,
+      credentialTarget,
       transport: {
         url: transport.url,
         type: transport.type,
@@ -135,7 +158,19 @@ function handleMcpAuthStatus({
   | { status: "complete" }
   | { status: "error"; error: string } {
   const { serverId } = pathParams as { serverId: string };
-  const state = getMcpAuthState(serverId);
+  const serverConfig = readEffectiveMcpConfig(loadWorkspaceMcpConfig()).servers[
+    serverId
+  ];
+  const target = serverConfig
+    ? resolveMcpOAuthCredentialTarget(serverId, serverConfig)
+    : null;
+  let targetKey: string | undefined;
+  try {
+    targetKey = target ? mcpOAuthCredentialKey(target, "tokens") : undefined;
+  } catch {
+    targetKey = undefined;
+  }
+  const state = targetKey ? getMcpAuthState(serverId, targetKey) : null;
 
   if (state === null) {
     throw new NotFoundError(`No active OAuth flow for server "${serverId}"`);
@@ -170,53 +205,6 @@ function handleMcpReload(_args: { body?: Record<string, unknown> }): {
   return { ok: true };
 }
 
-// ---------------------------------------------------------------------------
-// Health check helper
-// ---------------------------------------------------------------------------
-
-const HEALTH_CHECK_TIMEOUT_MS = 10_000;
-
-async function checkMachineReadableHealth(
-  serverId: string,
-  config: McpServerConfig,
-  timeoutMs = HEALTH_CHECK_TIMEOUT_MS,
-): Promise<string> {
-  const client = new McpClient(serverId);
-  try {
-    await Promise.race([
-      client.connect(config.transport),
-      new Promise<never>((_, reject) => {
-        const t = setTimeout(() => reject(new Error("timeout")), timeoutMs);
-        if (typeof t === "object" && "unref" in t) {
-          t.unref();
-        }
-      }),
-    ]);
-
-    if (client.isConnected) {
-      await client.disconnect();
-      return "connected";
-    }
-
-    const err = client.lastError;
-    if (err) {
-      if (err.message.includes("timeout")) {
-        return "error";
-      }
-      return "error";
-    }
-
-    return "needs-auth";
-  } catch {
-    try {
-      await client.disconnect();
-    } catch {
-      /* ignore */
-    }
-    return "error";
-  }
-}
-
 // ---------------------------------------------------------------------------
 // List
 // ---------------------------------------------------------------------------
@@ -271,12 +259,19 @@ async function handleMcpList(_args: {
   const configEntries = (
     Object.entries(servers) as [string, McpServerConfig][]
   ).filter(([, config]) => config && typeof config === "object");
+  const manager = getMcpServerManager();
 
   const workspaceEntries: McpServerEntry[] = await Promise.all(
     configEntries.map(async ([id, config]) => {
-      const status = await checkMachineReadableHealth(id, config);
+      const runtimeState = manager.getServerState(id, "workspace");
+      const status =
+        runtimeState === "connected" || runtimeState === "needs-auth"
+          ? runtimeState
+          : "error";
       const hasOAuth =
-        config.transport.type !== "stdio" ? await hasMcpOAuthTokens(id) : false;
+        config.transport.type !== "stdio"
+          ? await hasMcpOAuthTokens(workspaceMcpOAuthCredentialTarget(id))
+          : false;
 
       // Check credential store for stored static auth headers
       const storedHeaders = await getMcpHeaders(id);
@@ -316,21 +311,23 @@ async function handleMcpList(_args: {
   );
 
   return {
-    servers: [...workspaceEntries, ...listPluginServerEntries(configEntries)],
+    servers: [
+      ...workspaceEntries,
+      ...(await listPluginServerEntries(configEntries)),
+    ],
   };
 }
 
 /**
  * Project plugin-declared servers onto listing entries.
  *
- * Nothing here touches the credential store or the network: a plugin
- * server carries no auth state the assistant owns, and its status comes
- * from the manager's in-memory client rather than a probe (see
- * {@link PLUGIN_SERVER_STATUS}).
+ * OAuth presence is read from the plugin's scoped credential identity. Static
+ * workspace headers are never consulted, no network probe runs, and status
+ * comes from the manager's in-memory client (see {@link PLUGIN_SERVER_STATUS}).
  */
-function listPluginServerEntries(
+async function listPluginServerEntries(
   configEntries: [string, McpServerConfig][],
-): McpServerEntry[] {
+): Promise<McpServerEntry[]> {
   const { servers, issues } = readPluginMcpServers();
   for (const issue of issues) {
     log.warn(
@@ -349,36 +346,51 @@ function listPluginServerEntries(
   const workspaceIds = new Set(configEntries.map(([id]) => id));
   const manager = getMcpServerManager();
 
-  return servers
-    .filter((server) => {
-      if (!workspaceIds.has(server.id)) {
-        return true;
-      }
-      log.warn(
-        { plugin: server.pluginName, serverId: server.id },
-        "Plugin MCP server shadowed by a workspace server of the same id; skipping",
-      );
-      return false;
-    })
-    .map((server) => {
-      const { headers: _stripped, ...safeTransport } = server.config
-        .transport as Record<string, unknown>;
-      return {
-        id: server.id,
-        status: manager.getClient(server.id)?.isConnected
-          ? "connected"
-          : PLUGIN_SERVER_STATUS,
-        transport: safeTransport as McpServerEntry["transport"],
-        // A plugin server has no assistant-owned credentials. Resolving
-        // these against `mcp:<id>:*` would report, and could disclose, a
-        // workspace credential that happens to share the id.
-        hasOAuth: false,
-        hasStaticAuth: false,
-        authType: "none" as const,
-        source: "plugin" as const,
-        pluginName: server.pluginName,
-      };
-    });
+  return Promise.all(
+    servers
+      .filter((server) => {
+        if (!workspaceIds.has(server.id)) {
+          return true;
+        }
+        log.warn(
+          { plugin: server.pluginName, serverId: server.id },
+          "Plugin MCP server shadowed by a workspace server of the same id; skipping",
+        );
+        return false;
+      })
+      .map(async (server) => {
+        const { headers: _stripped, ...safeTransport } = server.config
+          .transport as Record<string, unknown>;
+        let hasOAuth = false;
+        const credentialTarget = resolveMcpOAuthCredentialTarget(
+          server.id,
+          server.config,
+        );
+        if (credentialTarget) {
+          try {
+            hasOAuth = await hasMcpOAuthTokens(credentialTarget);
+          } catch (err) {
+            log.warn(
+              { err, plugin: server.pluginName, serverId: server.id },
+              "Plugin MCP OAuth credential identity could not be resolved",
+            );
+          }
+        }
+        return {
+          id: server.id,
+          status:
+            manager.getServerState(server.id, "plugin") === "connected"
+              ? "connected"
+              : PLUGIN_SERVER_STATUS,
+          transport: safeTransport as McpServerEntry["transport"],
+          hasOAuth,
+          hasStaticAuth: false,
+          authType: "none" as const,
+          source: "plugin" as const,
+          pluginName: server.pluginName,
+        };
+      }),
+  );
 }
 
 // ---------------------------------------------------------------------------
@@ -687,7 +699,7 @@ export const ROUTES: RouteDefinition[] = [
     },
     summary: "List MCP servers with health status",
     description:
-      "Returns configured MCP servers with live health-check results (connected, needs auth, error).",
+      "Returns configured MCP servers with recorded runtime status without opening new connections.",
     tags: ["internal"],
     responseBody: z.object({
       servers: z.array(

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

@@ -80,6 +80,7 @@ import {
   PluginDirectoryNotFoundError,
 } from "../../cli/lib/toggle-plugin.js";
 import {
+  PLUGIN_UNINSTALL_WARNING_KEYS,
   PluginNotInstalledError,
   uninstallPlugin,
 } from "../../cli/lib/uninstall-plugin.js";
@@ -255,6 +256,14 @@ const pluginUninstallResponseSchema = z.object({
     .describe(
       "Absolute path that was removed on the assistant host. Useful for audit logs and confirmation toasts.",
     ),
+  warnings: z
+    .array(
+      z.literal(PLUGIN_UNINSTALL_WARNING_KEYS.MCP_OAUTH_CREDENTIALS_UNCHECKED),
+    )
+    .optional()
+    .describe(
+      "Stable keys for non-fatal cleanup limitations that should be localized at the presentation edge.",
+    ),
 });
 
 const pluginDetailsResponseSchema = z.object({
@@ -1134,7 +1143,11 @@ async function handleUninstallPlugin({
     const result = await uninstallPlugin({ name: rawName });
     await reconcilePluginSourcesNow();
     publishPluginsChanged(getOriginClientId(headers));
-    return { name: result.name, target: result.target };
+    return {
+      name: result.name,
+      target: result.target,
+      ...(result.warnings && { warnings: result.warnings }),
+    };
   } catch (err) {
     if (err instanceof InvalidPluginNameError) {
       throw new BadRequestError(err.message);

package/src/runtime/sync/resource-sync-events.ts

@@ -152,6 +152,10 @@ export function publishPluginsChanged(originClientId?: string): void {
   void publishSyncInvalidation([SYNC_TAGS.pluginsList], originClientId);
 }
 
+export function publishMcpChanged(): void {
+  void publishSyncInvalidation([SYNC_TAGS.mcpList]);
+}
+
 /**
  * Invalidate the activation-checklist progress resource on every client.
  *