@vellumai/assistant 0.8.1 → 0.8.2

package/src/runtime/routes/oauth-commands-routes.ts

@@ -7,7 +7,12 @@
 
 import { readFileSync } from "node:fs";
 
-import { getConfig, loadRawConfig, saveRawConfig, setNestedValue } from "../../config/loader.js";
+import {
+  getConfig,
+  loadRawConfig,
+  saveRawConfig,
+  setNestedValue,
+} from "../../config/loader.js";
 import {
   getServiceMode,
   type Services,
@@ -26,9 +31,11 @@ import {
   getProvider,
   listActiveConnectionsByProvider,
   listConnections,
+  type OAuthProviderRow,
 } from "../../oauth/oauth-store.js";
 import { VellumPlatformClient } from "../../platform/client.js";
 import { withValidToken } from "../../security/token-manager.js";
+import { matchHostPattern } from "../../tools/credentials/host-pattern-match.js";
 import { getLogger } from "../../util/logger.js";
 import { BadRequestError, InternalError, NotFoundError } from "./errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
@@ -121,6 +128,82 @@ async function countManagedConnections(provider: string): Promise<number> {
   }
 }
 
+function parseUrl(value: string | null | undefined): URL | undefined {
+  if (!value) return undefined;
+  try {
+    return new URL(value);
+  } catch {
+    return undefined;
+  }
+}
+
+function getAllowedRequestHostPatterns(
+  providerRow: OAuthProviderRow,
+): string[] {
+  const patterns: string[] = [];
+
+  if (providerRow.injectionTemplates) {
+    try {
+      const parsed = JSON.parse(providerRow.injectionTemplates) as unknown;
+      if (Array.isArray(parsed)) {
+        for (const entry of parsed) {
+          if (
+            entry &&
+            typeof entry === "object" &&
+            typeof (entry as { hostPattern?: unknown }).hostPattern === "string"
+          ) {
+            const hostPattern = (
+              entry as { hostPattern: string }
+            ).hostPattern.trim();
+            if (hostPattern) patterns.push(hostPattern);
+          }
+        }
+      }
+    } catch {
+      // Fall back to the provider's base URL host below.
+    }
+  }
+
+  if (patterns.length === 0) {
+    const baseUrl = parseUrl(providerRow.baseUrl);
+    if (baseUrl) patterns.push(baseUrl.hostname);
+  }
+
+  return [...new Set(patterns)];
+}
+
+function assertOAuthRequestUrlAllowed(
+  providerRow: OAuthProviderRow,
+  parsedUrl: URL,
+): void {
+  const providerBaseUrl = parseUrl(providerRow.baseUrl);
+  const allowedProtocol = providerBaseUrl?.protocol ?? "https:";
+  if (parsedUrl.protocol !== allowedProtocol) {
+    throw new BadRequestError(
+      `OAuth request URL for "${providerRow.provider}" must use ${allowedProtocol.replace(/:$/, "")}.`,
+    );
+  }
+
+  const allowedHostPatterns = getAllowedRequestHostPatterns(providerRow);
+  if (allowedHostPatterns.length === 0) {
+    throw new BadRequestError(
+      `OAuth provider "${providerRow.provider}" does not define an allowed request host.`,
+    );
+  }
+
+  const allowed = allowedHostPatterns.some(
+    (pattern) =>
+      matchHostPattern(parsedUrl.hostname, pattern, {
+        includeApexForWildcard: true,
+      }) !== "none",
+  );
+  if (!allowed) {
+    throw new BadRequestError(
+      `OAuth request URL host "${parsedUrl.hostname}" is not allowed for "${providerRow.provider}". Allowed hosts: ${allowedHostPatterns.join(", ")}.`,
+    );
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Disconnect handler
 // ---------------------------------------------------------------------------
@@ -176,7 +259,9 @@ async function handleDisconnect({ body = {} }: RouteHandlerArgs) {
       accountLabel = match.account_label;
     } else {
       if (entries.length === 0) {
-        throw new NotFoundError(`No active connections found for "${b.provider}".`);
+        throw new NotFoundError(
+          `No active connections found for "${b.provider}".`,
+        );
       }
       if (entries.length > 1) {
         throw new BadRequestError(
@@ -235,7 +320,9 @@ async function handleDisconnect({ body = {} }: RouteHandlerArgs) {
   } else {
     const active = listActiveConnectionsByProvider(b.provider);
     if (active.length === 0) {
-      throw new NotFoundError(`No active connections found for "${b.provider}".`);
+      throw new NotFoundError(
+        `No active connections found for "${b.provider}".`,
+      );
     }
     if (active.length > 1) {
       throw new BadRequestError(
@@ -582,11 +669,7 @@ async function handleToken({ body = {} }: RouteHandlerArgs) {
     tokenOpts = { connectionId: conn.id };
   }
 
-  const token = await withValidToken(
-    b.provider,
-    async (t) => t,
-    tokenOpts,
-  );
+  const token = await withValidToken(b.provider, async (t) => t, tokenOpts);
 
   return { ok: true, token };
 }
@@ -666,6 +749,7 @@ async function handleRequest({ body = {} }: RouteHandlerArgs) {
 
   if (b.url.startsWith("http://") || b.url.startsWith("https://")) {
     const parsed = new URL(b.url);
+    assertOAuthRequestUrlAllowed(providerRow, parsed);
     baseUrl = `${parsed.protocol}//${parsed.host}`;
     requestPath = parsed.pathname;
     for (const [key, value] of parsed.searchParams.entries()) {
@@ -717,7 +801,12 @@ async function handleRequest({ body = {} }: RouteHandlerArgs) {
   const query: Record<string, string | string[]> = { ...queryFromUrl };
 
   // Use pre-parsed data from CLI, or fall back to raw data string for direct API callers
-  const resolvedData = b.parsed_data !== undefined ? b.parsed_data : b.data !== undefined ? readBodyData(b.data) : undefined;
+  const resolvedData =
+    b.parsed_data !== undefined
+      ? b.parsed_data
+      : b.data !== undefined
+        ? readBodyData(b.data)
+        : undefined;
 
   if (resolvedData !== undefined) {
     const rawBody = resolvedData;
@@ -855,7 +944,9 @@ async function handleManagedConnect({ body = {} }: RouteHandlerArgs) {
   return { ok: true, connect_url: result.connect_url };
 }
 
-async function handleManagedConnectPoll({ queryParams = {} }: RouteHandlerArgs) {
+async function handleManagedConnectPoll({
+  queryParams = {},
+}: RouteHandlerArgs) {
   const provider = queryParams.provider;
   if (!provider) throw new BadRequestError("provider query param is required");
 
@@ -894,7 +985,8 @@ export const ROUTES: RouteDefinition[] = [
     endpoint: "oauth/mode",
     method: "GET",
     summary: "Get OAuth mode",
-    description: "Get the current OAuth mode (managed or your-own) for a provider.",
+    description:
+      "Get the current OAuth mode (managed or your-own) for a provider.",
     tags: ["oauth"],
     requirePolicyEnforcement: true,
     queryParams: [
@@ -913,8 +1005,7 @@ export const ROUTES: RouteDefinition[] = [
     method: "POST",
     policyKey: "oauth/mode.set",
     summary: "Set OAuth mode",
-    description:
-      "Set the OAuth mode (managed or your-own) for a provider.",
+    description: "Set the OAuth mode (managed or your-own) for a provider.",
     tags: ["oauth"],
     requirePolicyEnforcement: true,
     handler: handleModeSet,
@@ -955,8 +1046,7 @@ export const ROUTES: RouteDefinition[] = [
     method: "POST",
     policyKey: "oauth/token",
     summary: "Get OAuth token",
-    description:
-      "Retrieve a valid OAuth access token for a BYO-mode provider.",
+    description: "Retrieve a valid OAuth access token for a BYO-mode provider.",
     tags: ["oauth"],
     requirePolicyEnforcement: true,
     handler: handleToken,

package/src/runtime/routes/oauth-lifecycle-routes.ts

@@ -0,0 +1,43 @@
+/**
+ * Transport-agnostic routes for OAuth lifecycle events.
+ *
+ * Allows CLI commands to notify the daemon when OAuth state changes
+ * (e.g. after `assistant oauth connect`) so the daemon can refresh its
+ * cached config and credential state.
+ */
+
+import { z } from "zod";
+
+import { getConfig, invalidateConfigCache } from "../../config/loader.js";
+import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
+
+// ── Handlers ──────────────────────────────────────────────────────────
+
+function handleOAuthConnectionChanged(_args: RouteHandlerArgs): {
+  refreshed: boolean;
+} {
+  invalidateConfigCache();
+  // Force re-read from disk so subsequent resolveOAuthConnection() calls
+  // in this process see the current mode setting.
+  getConfig();
+  return { refreshed: true };
+}
+
+// ── Routes ────────────────────────────────────────────────────────────
+
+export const ROUTES: RouteDefinition[] = [
+  {
+    operationId: "oauth_connection_changed",
+    endpoint: "oauth/connection-changed",
+    method: "POST",
+    policyKey: "oauth/connection-changed",
+    handler: handleOAuthConnectionChanged,
+    summary: "Notify the assistant that an OAuth connection changed",
+    description:
+      "Invalidates the config cache so the assistant picks up mode and credential changes immediately.",
+    tags: ["oauth"],
+    responseBody: z.object({
+      refreshed: z.boolean(),
+    }),
+  },
+];

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

@@ -0,0 +1,259 @@
+/**
+ * Route handler for resolving pending question prompts.
+ *
+ * POST /v1/question-response — a client (UI or remote channel) submits the
+ * user's selection for a pending ask-question interaction registered by
+ * {@link QuestionPrompter}. Two top-level shapes are accepted:
+ *
+ *  - `kind: "submit"` carries a `responses` array — one entry per question in
+ *    the original batch. The web client builds this locally and POSTs it once
+ *    the user is done revising the card.
+ *  - `kind: "close"` records that the user dismissed the card without
+ *    answering; every entry is reported as `skipped`.
+ *
+ * For backwards-compat we also accept the prior single-question shape
+ * (`{ kind: "option" | "free_text", ... }`) as syntactic sugar for a
+ * one-element batch. That branch only succeeds against a single-question
+ * batch — multi-question batches reject it with a helpful error.
+ *
+ * Cross-talk safety: pending interactions of other kinds (`confirmation`,
+ * `secret`, host_*, etc.) return 404 here rather than being mis-resolved.
+ */
+import { z } from "zod";
+
+import {
+  buildBatchEntries,
+  type QuestionBatchMetadata,
+  type QuestionBatchSubmission,
+  QuestionBatchValidationError,
+  type QuestionPromptResult,
+} from "../../permissions/question-prompter.js";
+import { getLogger } from "../../util/logger.js";
+import * as pendingInteractions from "../pending-interactions.js";
+import { BadRequestError, NotFoundError } from "./errors.js";
+import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
+
+const log = getLogger("question-routes");
+
+// ── Batched (current) body shape ────────────────────────────────────
+
+const SubmitEntry = z.discriminatedUnion("kind", [
+  z.object({
+    questionId: z.string(),
+    kind: z.literal("option"),
+    optionId: z.string(),
+  }),
+  z.object({
+    questionId: z.string(),
+    kind: z.literal("free_text"),
+    text: z.string(),
+  }),
+  z.object({
+    questionId: z.string(),
+    kind: z.literal("skip"),
+  }),
+]);
+
+const SubmitBody = z.object({
+  requestId: z.string(),
+  kind: z.literal("submit"),
+  responses: z.array(SubmitEntry).min(1),
+});
+
+const CloseBody = z.object({
+  requestId: z.string(),
+  kind: z.literal("close"),
+});
+
+// ── Legacy single-question body shape (sugar for one-element batch) ──
+
+const LegacyOptionBody = z.object({
+  requestId: z.string(),
+  kind: z.literal("option"),
+  optionId: z.string(),
+});
+
+const LegacyFreeTextBody = z.object({
+  requestId: z.string(),
+  kind: z.literal("free_text"),
+  text: z.string(),
+});
+
+// All four variants are mutually exclusive by their `kind` literal, so use
+// `discriminatedUnion` rather than plain `union`. The generated OpenAPI then
+// emits `oneOf` for the body (matching the pre-batched-shape spec) instead
+// of the looser `anyOf` that `z.union` produces.
+const QuestionResponseBody = z.discriminatedUnion("kind", [
+  SubmitBody,
+  CloseBody,
+  LegacyOptionBody,
+  LegacyFreeTextBody,
+]);
+
+type SubmitBody = z.infer<typeof SubmitBody>;
+type CloseBody = z.infer<typeof CloseBody>;
+type LegacyOptionBody = z.infer<typeof LegacyOptionBody>;
+type LegacyFreeTextBody = z.infer<typeof LegacyFreeTextBody>;
+type QuestionResponseBody = z.infer<typeof QuestionResponseBody>;
+
+/**
+ * POST /v1/question-response — resolve a pending ask-question interaction.
+ */
+function handleQuestionResponse({ body }: RouteHandlerArgs) {
+  const parsed = QuestionResponseBody.safeParse(body);
+  if (!parsed.success) {
+    throw new BadRequestError(
+      `Invalid question response body: ${parsed.error.message}`,
+    );
+  }
+
+  const response: QuestionResponseBody = parsed.data;
+  const { requestId } = response;
+
+  const interaction = pendingInteractions.get(requestId);
+  if (!interaction || interaction.kind !== "question") {
+    log.warn(
+      { requestId, foundKind: interaction?.kind },
+      "Question response for unknown or wrong-kind requestId",
+    );
+    throw new NotFoundError(
+      "No pending question interaction found for this requestId",
+    );
+  }
+
+  // Build + validate the result BEFORE touching `pendingInteractions`, so a
+  // bad payload leaves the pending interaction (and its timer) intact and the
+  // user gets another chance to submit a correct batch.
+  let result: QuestionPromptResult;
+  try {
+    if (response.kind === "close") {
+      const { orderedIds } = readBatchMetadata(interaction);
+      result = {
+        entries: orderedIds.map((id) => ({
+          questionId: id,
+          decision: "skipped" as const,
+        })),
+        overall: "closed",
+      };
+    } else {
+      const submissions = buildSubmissions(response, interaction);
+      result = buildCompletedResult(submissions, interaction);
+    }
+  } catch (err) {
+    if (err instanceof QuestionBatchValidationError) {
+      throw new BadRequestError(err.message);
+    }
+    throw err;
+  }
+
+  // Validation passed — deregister now to clear the prompter timer, then
+  // hand the result to the prompter's caller via rpcResolve.
+  pendingInteractions.resolve(requestId);
+
+  log.info(
+    {
+      requestId,
+      overall: result.overall,
+      conversationId: interaction.conversationId,
+    },
+    "Question resolved",
+  );
+
+  (interaction.rpcResolve as
+    | ((value: QuestionPromptResult) => void)
+    | undefined)?.(result);
+
+  return { success: true };
+}
+
+/**
+ * Normalize the incoming body to a `QuestionBatchSubmission[]` for the
+ * submit/legacy paths. Returns `null` for the `close` path (no submissions).
+ */
+function buildSubmissions(
+  body: SubmitBody | LegacyOptionBody | LegacyFreeTextBody,
+  interaction: ReturnType<typeof pendingInteractions.get>,
+): QuestionBatchSubmission[] {
+  if (body.kind === "submit") return body.responses;
+
+  // Legacy single-question shim: synthesize a one-element batch. The
+  // prompter stashed the ordered ids on the interaction metadata so we can
+  // pick the (single) target questionId here.
+  const { orderedIds } = readBatchMetadata(interaction);
+  if (orderedIds.length === 0) {
+    throw new QuestionBatchValidationError(
+      "Legacy single-question payload requires a registered batch with at least one question",
+    );
+  }
+  if (orderedIds.length > 1) {
+    throw new QuestionBatchValidationError(
+      'Legacy single-question payload cannot answer a multi-question batch; submit `{ kind: "submit", responses: [...] }` covering every question instead.',
+    );
+  }
+  const questionId = orderedIds[0]!;
+  if (body.kind === "option") {
+    return [{ questionId, kind: "option", optionId: body.optionId }];
+  }
+  return [{ questionId, kind: "free_text", text: body.text }];
+}
+
+/**
+ * Build a `completed` QuestionPromptResult from a batched submission and the
+ * per-question metadata the prompter stashed on the interaction. Delegates
+ * the validation + ordering loop to {@link buildBatchEntries} so the
+ * prompter and the route share a single implementation.
+ */
+function buildCompletedResult(
+  submissions: QuestionBatchSubmission[],
+  interaction: ReturnType<typeof pendingInteractions.get>,
+): QuestionPromptResult {
+  const { orderedIds, optionsById } = readBatchMetadata(interaction);
+  if (orderedIds.length === 0) {
+    throw new QuestionBatchValidationError(
+      "No registered question ids for this batch",
+    );
+  }
+  const entries = buildBatchEntries(
+    orderedIds,
+    (qid, oid) => (optionsById[qid] ?? []).includes(oid),
+    new Set(Object.keys(optionsById)),
+    submissions,
+  );
+  return { entries, overall: "completed" };
+}
+
+/**
+ * Pull the prompter-stashed batch bookkeeping off a pending interaction.
+ * Returns empty defaults if the metadata is absent.
+ */
+function readBatchMetadata(
+  interaction: ReturnType<typeof pendingInteractions.get>,
+): QuestionBatchMetadata {
+  const meta = interaction?.metadata as Partial<QuestionBatchMetadata> | undefined;
+  return {
+    orderedIds: meta?.orderedIds ?? [],
+    optionsById: meta?.optionsById ?? {},
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Route definitions
+// ---------------------------------------------------------------------------
+
+export const ROUTES: RouteDefinition[] = [
+  {
+    operationId: "question_response",
+    endpoint: "question-response",
+    method: "POST",
+    handler: handleQuestionResponse,
+    requireGuardian: true,
+    summary: "Resolve a pending ask-question prompt",
+    description:
+      "Submit the user's batched response (or close the card) for a pending question prompt by requestId. Legacy single-question payloads remain accepted as syntactic sugar for a one-element batch.",
+    tags: ["approvals"],
+    requestBody: QuestionResponseBody,
+    responseBody: z.object({
+      success: z.boolean(),
+    }),
+  },
+];

package/src/runtime/routes/rename-conversation-routes.ts

@@ -13,9 +13,7 @@ import {
   getConversation,
   updateConversationTitle,
 } from "../../memory/conversation-crud.js";
-import { getLogger } from "../../util/logger.js";
-import { buildAssistantEvent } from "../assistant-event.js";
-import { assistantEventHub } from "../assistant-event-hub.js";
+import { publishConversationTitleChanged } from "../sync/resource-sync-events.js";
 import { BadRequestError, NotFoundError } from "./errors.js";
 import type { RouteDefinition } from "./types.js";
 
@@ -24,8 +22,6 @@ const RenameConversationBody = z.object({
   title: z.string().min(1),
 });
 
-const log = getLogger("rename-conversation-routes");
-
 export const ROUTES: RouteDefinition[] = [
   {
     operationId: "rename_conversation",
@@ -50,34 +46,7 @@ export const ROUTES: RouteDefinition[] = [
 
       updateConversationTitle(conversationId, title, 0);
 
-      assistantEventHub
-        .publish(
-          buildAssistantEvent(
-            {
-              type: "conversation_title_updated",
-              conversationId,
-              title,
-            },
-            conversationId,
-          ),
-        )
-        .catch((err) => {
-          log.warn({ err }, "Failed to publish conversation_title_updated");
-        });
-
-      assistantEventHub
-        .publish(
-          buildAssistantEvent({
-            type: "conversation_list_invalidated",
-            reason: "renamed",
-          }),
-        )
-        .catch((err) => {
-          log.warn(
-            { err },
-            "Failed to publish conversation_list_invalidated for rename",
-          );
-        });
+      publishConversationTitleChanged(conversationId, title);
 
       return { ok: true };
     },

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

@@ -78,7 +78,8 @@ function handleCreateSchedule(body: Record<string, unknown>) {
   const expression =
     typeof body.expression === "string" ? body.expression.trim() : "";
   const message = typeof body.message === "string" ? body.message : "";
-  const timezoneRaw = typeof body.timezone === "string" ? body.timezone.trim() : "";
+  const timezoneRaw =
+    typeof body.timezone === "string" ? body.timezone.trim() : "";
   const timezone = timezoneRaw === "" ? null : timezoneRaw;
   const enabled = body.enabled !== false;
   const mode = (body.mode as string | undefined) ?? "execute";
@@ -298,16 +299,12 @@ export const ROUTES: RouteDefinition[] = [
         .boolean()
         .describe("Whether the schedule starts active (default true)")
         .optional(),
-      mode: z
-        .string()
-        .describe("Currently must be 'execute'")
-        .optional(),
+      mode: z.string().describe("Currently must be 'execute'").optional(),
     }),
     responseBody: z.object({
       schedules: z.array(z.unknown()).describe("Updated schedule list"),
     }),
-    handler: ({ body }: RouteHandlerArgs) =>
-      handleCreateSchedule(body ?? {}),
+    handler: ({ body }: RouteHandlerArgs) => handleCreateSchedule(body ?? {}),
   },
   {
     operationId: "listScheduleRuns",