@vellumai/assistant 0.8.3 → 0.8.5

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

@@ -0,0 +1,200 @@
+/**
+ * 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.
+ */
+
+import { z } from "zod";
+
+import { findConversation } from "../../daemon/conversation-store.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 { browserCliConversationKey } from "./browser-routes.js";
+import { BadRequestError } from "./errors.js";
+import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
+
+const BrowserTabsParams = z.object({
+  command: z.enum(["list", "select", "new", "close"]),
+  sessionId: z.string().min(1).default("default"),
+  conversationId: z.string().min(1).optional(),
+  tabId: z.number().optional(),
+  url: z.string().optional(),
+  // Route tab operations to a specific extension client in multi-client
+  // setups. Mirrors browser/execute's `target_client_id` semantics.
+  targetClientId: z.string().min(1).optional(),
+});
+
+async function handleBrowserTabs({ body = {} }: RouteHandlerArgs) {
+  const { command, sessionId, conversationId, tabId, url, targetClientId } =
+    BrowserTabsParams.parse(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;
+
+  const cdpOptions = { mode: "extension" as const, targetClientId };
+
+  if (command === "list") {
+    const cdp = getCdpClient(context, cdpOptions);
+    try {
+      const tabs = await cdp.listTabs();
+      return { ok: true, tabs };
+    } finally {
+      cdp.dispose();
+    }
+  }
+
+  if (command === "select") {
+    if (tabId === undefined) {
+      throw new BadRequestError("tabId is required for the select command");
+    }
+    const cdp = getCdpClient(context, cdpOptions);
+    try {
+      const result = await cdp.selectTab(tabId);
+      const clientId =
+        typeof result?.clientId === "string" && result.clientId.length > 0
+          ? result.clientId
+          : undefined;
+      if (result?.tabId !== undefined) {
+        setPinnedTab(
+          resolvedConversationId,
+          String(result.tabId),
+          clientId,
+        );
+      }
+      return { ok: true, tab: result };
+    } finally {
+      cdp.dispose();
+    }
+  }
+
+  if (command === "new") {
+    const cdp = getCdpClient(context, cdpOptions);
+    try {
+      const result = await cdp.send<{ tabId?: number | string; clientId?: string }>(
+        "Vellum.createTab",
+        {},
+      );
+      // Normalise to string for internal use (setCdpSessionId / setPinnedTab)
+      // and keep the numeric form for the API response.
+      const newTabIdStr: string | undefined =
+        typeof result?.tabId === "number"
+          ? String(result.tabId)
+          : typeof result?.tabId === "string"
+            ? result.tabId
+            : undefined;
+      const newTabIdNum: number | undefined =
+        typeof result?.tabId === "number"
+          ? result.tabId
+          : typeof result?.tabId === "string"
+            ? parseInt(result.tabId, 10)
+            : undefined;
+      const clientId =
+        typeof result?.clientId === "string" && result.clientId.length > 0
+          ? result.clientId
+          : undefined;
+      if (newTabIdStr) {
+        cdp.setCdpSessionId?.(newTabIdStr);
+        setPinnedTab(resolvedConversationId, newTabIdStr, clientId);
+        if (url) {
+          await cdp.send("Page.navigate", { url });
+        }
+      } else if (targetClientId) {
+        // Only scope-clear the targeted client's pin. With the per-(conversationId,
+        // clientId) pin store (#31361), passing no clientId to clearPinnedTab
+        // would wipe pins for *every* connected client on this conversation
+        // and break their routing — so we skip the clear entirely when the
+        // caller didn't explicitly target a client. The stale pin (if any)
+        // is overwritten on the next successful tab operation.
+        clearPinnedTab(resolvedConversationId, targetClientId);
+      }
+      return { ok: true, tabId: newTabIdNum, clientId };
+    } finally {
+      cdp.dispose();
+    }
+  }
+
+  if (command === "close") {
+    if (tabId === undefined) {
+      throw new BadRequestError("tabId is required for the close command");
+    }
+    const cdp = getCdpClient(context, cdpOptions);
+    try {
+      const result = await cdp.closeTab(tabId);
+      // Clear any pinned-tab slot still pointing at the closed tabId so
+      // subsequent browser tool calls don't route to a dead cdpSessionId
+      // and fail with session-not-found. Tabs that never debugger-attached
+      // (e.g. `tabs new` without `--url`) won't emit a detach invalidation
+      // event, so the pin would otherwise leak.
+      //
+      // Scope the clear to the actual responding client. Prefer the
+      // clientId from the closeTab response (resolved by the extension
+      // dispatcher), fall back to the caller-supplied targetClientId.
+      // Without a resolved clientId we skip the clear entirely — calling
+      // clearPinnedTabByTabId without a clientId would wipe matching pins
+      // across every client (Chrome tab IDs are per-instance, not
+      // globally unique), breaking the per-(conversationId, clientId)
+      // pin isolation added in #31361. The stale pin in the unscoped
+      // case will self-heal via the session-not-found cleanup on the
+      // next browser op against that pin.
+      const resolvedClientId = result.clientId ?? targetClientId;
+      if (resolvedClientId) {
+        clearPinnedTabByTabId(String(tabId), resolvedClientId);
+      }
+      return { ok: true, ...result };
+    } finally {
+      cdp.dispose();
+    }
+  }
+
+  throw new BadRequestError(`Unknown tabs command: ${command}`);
+}
+
+export const ROUTES: RouteDefinition[] = [
+  {
+    operationId: "browser_tabs",
+    endpoint: "browser/tabs",
+    method: "POST",
+    handler: handleBrowserTabs,
+    summary: "Manage browser tabs",
+    description:
+      "List, create, select, or close browser tabs via the Chrome extension backend.",
+    tags: ["browser"],
+    requestBody: BrowserTabsParams,
+    responseBody: z.object({
+      ok: z.boolean(),
+      tabs: z
+        .array(
+          z.object({
+            tabId: z.number().optional(),
+            windowId: z.number().optional(),
+            url: z.string().optional(),
+            title: z.string().optional(),
+            active: z.boolean(),
+            pinned: z.boolean(),
+          }),
+        )
+        .optional(),
+      tab: z.unknown().optional(),
+      tabId: z.number().optional(),
+      clientId: z.string().optional(),
+      closed: z.boolean().optional(),
+    }),
+  },
+];

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

@@ -22,7 +22,6 @@ import { getOrCreateConversation } from "../../daemon/conversation-store.js";
 import { buildToolDefinitions } from "../../daemon/conversation-tool-setup.js";
 import { parseIdentityFields } from "../../daemon/handlers/identity.js";
 import { getConversationByKey } from "../../memory/conversation-key-store.js";
-import { resolvePersonaContext } from "../../prompts/persona-resolver.js";
 import { getLogger } from "../../util/logger.js";
 import { getWorkspacePromptPath } from "../../util/platform.js";
 import { runBtwSidechain } from "../btw-sidechain.js";
@@ -120,16 +119,11 @@ async function handleBtw({
         try {
           const isIntroRequest = conversationKey === IDENTITY_INTRO_KEY;
           const isGreeting = conversationKey === GREETING_KEY;
-          const { userPersona, userSlug, channelPersona } =
-            resolvePersonaContext(undefined, undefined);
           const result = await runBtwSidechain({
             content: effectiveContent,
             conversation,
             tools: buildToolDefinitions(),
             signal: abortSignal,
-            userPersona,
-            channelPersona,
-            userSlug,
             ...(isGreeting ? { callSite: "emptyStateGreeting" as const } : {}),
             onEvent: (event) => {
               if (event.type === "text_delta") {

package/src/runtime/routes/chatgpt-subscription-auth-routes.ts

@@ -0,0 +1,246 @@
+/**
+ * Route definitions for ChatGPT subscription OAuth authentication.
+ *
+ * POST /v1/inference/chatgpt-subscription/auth — generate a PKCE authorize
+ *   URL for the user to visit. Returns `{ authorize_url, state }`.
+ *
+ * POST /v1/inference/chatgpt-subscription/auth/exchange — accept the
+ *   authorization code + state from the redirect, exchange for tokens,
+ *   store in CES, and upsert the provider connection.
+ */
+
+import { z } from "zod";
+
+import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
+import { getConfigReadOnly } from "../../config/loader.js";
+import { getDb } from "../../memory/db-connection.js";
+import {
+  createConnection,
+  getConnection,
+  updateConnection,
+} from "../../providers/inference/connections.js";
+import type { OAuth2Config } from "../../security/oauth2.js";
+import {
+  exchangeCodeForTokens,
+  generateCodeChallenge,
+  generateCodeVerifier,
+  generateState,
+} from "../../security/oauth2.js";
+import { setSecureKeyAsync } from "../../security/secure-keys.js";
+import { getLogger } from "../../util/logger.js";
+import { BadRequestError } from "./errors.js";
+import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
+
+function requireFeatureFlag() {
+  const config = getConfigReadOnly();
+  if (!isAssistantFeatureFlagEnabled("chatgpt-subscription-auth", config)) {
+    throw new BadRequestError(
+      "ChatGPT subscription auth is not enabled for this assistant.",
+    );
+  }
+}
+
+const log = getLogger("chatgpt-subscription-auth");
+
+// ---------------------------------------------------------------------------
+// OAuth config
+// ---------------------------------------------------------------------------
+
+const OPENAI_OAUTH_CONFIG: OAuth2Config = {
+  authorizeUrl: "https://auth.openai.com/oauth/authorize",
+  tokenExchangeUrl: "https://auth.openai.com/oauth/token",
+  clientId: "app_EMoamEEZ73f0CkXaXp7hrann",
+  scopes: ["openid", "profile", "email", "offline_access"],
+  scopeSeparator: " ",
+  authorizeParams: { id_token_add_organizations: "true" },
+};
+
+const REDIRECT_URI = "http://localhost:1455/auth/callback";
+const CONNECTION_NAME = "chatgpt-subscription";
+
+// ---------------------------------------------------------------------------
+// Module-level PKCE state storage
+// ---------------------------------------------------------------------------
+
+interface PendingAuth {
+  codeVerifier: string;
+  createdAt: number;
+}
+
+const pendingAuths = new Map<string, PendingAuth>();
+
+const PENDING_AUTH_TTL_MS = 10 * 60 * 1000; // 10 minutes
+
+/** Remove entries older than 10 minutes. */
+function cleanupExpiredEntries(): void {
+  const cutoff = Date.now() - PENDING_AUTH_TTL_MS;
+  for (const [key, entry] of pendingAuths) {
+    if (entry.createdAt < cutoff) {
+      pendingAuths.delete(key);
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Handlers
+// ---------------------------------------------------------------------------
+
+async function handleStartAuth(_args: RouteHandlerArgs) {
+  requireFeatureFlag();
+  cleanupExpiredEntries();
+
+  const codeVerifier = generateCodeVerifier();
+  const codeChallenge = generateCodeChallenge(codeVerifier);
+  const state = generateState();
+
+  pendingAuths.set(state, { codeVerifier, createdAt: Date.now() });
+
+  const params = new URLSearchParams({
+    response_type: "code",
+    client_id: OPENAI_OAUTH_CONFIG.clientId,
+    redirect_uri: REDIRECT_URI,
+    scope: OPENAI_OAUTH_CONFIG.scopes.join(
+      OPENAI_OAUTH_CONFIG.scopeSeparator,
+    ),
+    state,
+    code_challenge: codeChallenge,
+    code_challenge_method: "S256",
+    ...OPENAI_OAUTH_CONFIG.authorizeParams,
+  });
+
+  const authorizeUrl = `${OPENAI_OAUTH_CONFIG.authorizeUrl}?${params.toString()}`;
+
+  return { authorize_url: authorizeUrl, state };
+}
+
+async function handleExchange(args: RouteHandlerArgs) {
+  requireFeatureFlag();
+  const { code, state } = args.body as { code: string; state: string };
+
+  const pending = pendingAuths.get(state);
+  if (!pending) {
+    throw new Error(
+      "Invalid or expired state parameter. Please restart the auth flow.",
+    );
+  }
+
+  pendingAuths.delete(state);
+
+  // Check TTL
+  if (Date.now() - pending.createdAt > PENDING_AUTH_TTL_MS) {
+    throw new Error("Auth flow expired. Please restart the auth flow.");
+  }
+
+  const { tokens } = await exchangeCodeForTokens(
+    OPENAI_OAUTH_CONFIG,
+    code,
+    REDIRECT_URI,
+    pending.codeVerifier,
+  );
+
+  // Store tokens in CES
+  const accessStored = await setSecureKeyAsync(
+    "credential/chatgpt/access_token",
+    tokens.accessToken,
+  );
+  if (!accessStored) {
+    log.error("Failed to store ChatGPT access token in CES");
+    throw new Error("Failed to store access token");
+  }
+
+  if (tokens.refreshToken) {
+    const refreshStored = await setSecureKeyAsync(
+      "credential/chatgpt/refresh_token",
+      tokens.refreshToken,
+    );
+    if (!refreshStored) {
+      log.error("Failed to store ChatGPT refresh token in CES");
+      throw new Error("Failed to store refresh token");
+    }
+  }
+
+  if (tokens.expiresIn) {
+    const expiresAt = Math.floor(Date.now() / 1000 + tokens.expiresIn);
+    await setSecureKeyAsync(
+      "credential/chatgpt/expires_at",
+      String(expiresAt),
+    );
+  }
+
+  // Upsert provider connection
+  const db = getDb();
+  const authInput = {
+    type: "oauth_subscription" as const,
+    credential: "credential/chatgpt/access_token",
+  };
+
+  const existing = getConnection(db, CONNECTION_NAME);
+  if (existing) {
+    const updateResult = updateConnection(db, CONNECTION_NAME, {
+      auth: authInput,
+    });
+    if (!updateResult.ok) {
+      log.error(
+        { error: updateResult.error },
+        "Failed to update chatgpt-subscription connection",
+      );
+      throw new Error("Failed to update connection");
+    }
+  } else {
+    const createResult = createConnection(db, {
+      name: CONNECTION_NAME,
+      provider: "openai",
+      auth: authInput,
+    });
+    if (!createResult.ok) {
+      log.error(
+        { error: createResult.error },
+        "Failed to create chatgpt-subscription connection",
+      );
+      throw new Error("Failed to create connection");
+    }
+  }
+
+  log.info("ChatGPT subscription auth flow completed successfully");
+  return { ok: true };
+}
+
+// ---------------------------------------------------------------------------
+// Route definitions
+// ---------------------------------------------------------------------------
+
+export const ROUTES: RouteDefinition[] = [
+  {
+    operationId: "inference_chatgpt_subscription_auth",
+    endpoint: "inference/chatgpt-subscription/auth",
+    method: "POST",
+    policyKey: "inference/provider-connections",
+    summary: "Start ChatGPT subscription OAuth PKCE flow",
+    description:
+      "Generate a PKCE authorize URL for ChatGPT subscription auth. Returns the URL and state for the client to open in a browser.",
+    tags: ["inference"],
+    responseBody: z.object({
+      authorize_url: z.string(),
+      state: z.string(),
+    }),
+    handler: handleStartAuth,
+  },
+  {
+    operationId: "inference_chatgpt_subscription_auth_exchange",
+    endpoint: "inference/chatgpt-subscription/auth/exchange",
+    method: "POST",
+    policyKey: "inference/provider-connections",
+    summary: "Exchange ChatGPT subscription OAuth authorization code",
+    description:
+      "Accept an authorization code and state from the OAuth redirect, exchange it for tokens, store them in CES, and upsert the provider connection.",
+    tags: ["inference"],
+    requestBody: z.object({
+      code: z.string(),
+      state: z.string(),
+    }),
+    responseBody: z.object({
+      ok: z.boolean(),
+    }),
+    handler: handleExchange,
+  },
+];

package/src/runtime/routes/content-source-routes.ts

@@ -0,0 +1,78 @@
+/**
+ * Route definitions for content-source configuration.
+ *
+ * POST /v1/content-source — validate and persist a content source URL as sidecar
+ *
+ * Uses policyKey: "secrets" — writes workspace data, same policy tier as
+ * the existing secrets routes.
+ */
+
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+import { z } from "zod";
+
+import { getWorkspaceDir } from "../../util/platform.js";
+import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function writeSidecar(relPath: string, data: Record<string, unknown>): void {
+  const workspaceDir = getWorkspaceDir();
+  const absPath = join(workspaceDir, relPath);
+  mkdirSync(dirname(absPath), { recursive: true });
+  writeFileSync(absPath, JSON.stringify(data, null, 2), "utf-8");
+}
+
+function validateUrl(
+  raw: string,
+): { ok: true; normalized: string } | { ok: false; error: "invalid_url" } {
+  const trimmed = raw.trim();
+  let parsed: URL;
+  try {
+    parsed = new URL(trimmed);
+  } catch {
+    return { ok: false, error: "invalid_url" };
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    return { ok: false, error: "invalid_url" };
+  }
+  parsed.username = "";
+  parsed.password = "";
+  return { ok: true, normalized: parsed.href };
+}
+
+// ---------------------------------------------------------------------------
+// POST /v1/content-source
+// ---------------------------------------------------------------------------
+
+function handleContentSource(args: RouteHandlerArgs): Record<string, unknown> {
+  const rawUrl = typeof args.body?.url === "string" ? args.body.url : "";
+
+  const result = validateUrl(rawUrl);
+  if (!result.ok) {
+    return { ok: false, error: result.error };
+  }
+
+  writeSidecar("data/content-source.json", { url: result.normalized });
+
+  return { ok: true };
+}
+
+// ---------------------------------------------------------------------------
+// Route definition
+// ---------------------------------------------------------------------------
+
+export const ROUTES: RouteDefinition[] = [
+  {
+    operationId: "content_source_set",
+    endpoint: "content-source",
+    method: "POST",
+    policyKey: "secrets",
+    summary: "Validate and persist a content source URL",
+    requestBody: z.object({ url: z.string() }),
+    handler: handleContentSource,
+  },
+];