@vellumai/assistant 0.11.6 → 0.11.7-staging.2

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

@@ -46,6 +46,8 @@ import {
 import { getLogger } from "../../util/logger.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
 import { BadRequestError, NotFoundError } from "./errors.js";
+import type { PendingFlowStatus } from "./oauth-pending-flows.js";
+import { createPendingFlowRegistry } from "./oauth-pending-flows.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
 const log = getLogger("acp-claude-auth");
@@ -58,53 +60,24 @@ const CLAUDE_LOOPBACK_CALLBACK_PATH = "/callback";
 // Pending-flow tracking (shared by the loopback + manual/cloud branches)
 // ---------------------------------------------------------------------------
 
-type FlowStatus = "pending" | "connected" | "error";
-
-interface PendingFlow {
-  status: FlowStatus;
-  error?: string;
-  createdAt: number;
-  /**
-   * Cloud/manual path only: the PKCE verifier + redirect the pasted code is
-   * exchanged with. Absent on loopback flows (the daemon exchanges those
-   * itself), which also keeps loopback entries from being exchangeable via the
-   * manual `exchange` route.
-   */
-  codeVerifier?: string;
-  redirectUri?: string;
-}
-
 interface StartResponse {
   mode: "loopback" | "manual";
   authorize_url: string;
   state: string;
 }
 
-const pendingFlows = new Map<string, PendingFlow>();
-
-const PENDING_FLOW_TTL_MS = 10 * 60 * 1000; // 10 minutes
-
-/** Remove entries older than the TTL so the map can't grow unbounded. */
-function cleanupExpiredFlows(): void {
-  const cutoff = Date.now() - PENDING_FLOW_TTL_MS;
-  for (const [state, flow] of pendingFlows) {
-    if (flow.createdAt < cutoff) {
-      pendingFlows.delete(state);
-    }
-  }
+/**
+ * The extra state a manual/cloud flow carries: the PKCE verifier + redirect the
+ * pasted code is exchanged with. Absent on loopback flows (the daemon exchanges
+ * those itself), which also keeps loopback entries from being exchangeable via
+ * the manual `exchange` route.
+ */
+interface ClaudeFlowState {
+  codeVerifier?: string;
+  redirectUri?: string;
 }
 
-/** Update a tracked flow's status in place, if it still exists. */
-function markFlow(state: string, status: FlowStatus, error?: string): void {
-  const flow = pendingFlows.get(state);
-  if (!flow) {
-    return;
-  }
-  flow.status = status;
-  if (error !== undefined) {
-    flow.error = error;
-  }
-}
+const pendingFlows = createPendingFlowRegistry<ClaudeFlowState>();
 
 // ---------------------------------------------------------------------------
 // Handlers
@@ -125,7 +98,7 @@ function markFlow(state: string, status: FlowStatus, error?: string): void {
  * asked to serve them.
  */
 async function handleStartAuth(args: RouteHandlerArgs): Promise<StartResponse> {
-  cleanupExpiredFlows();
+  pendingFlows.cleanupExpired();
 
   const preferManual = Boolean(
     (args.body as { preferManual?: boolean } | undefined)?.preferManual,
@@ -146,7 +119,7 @@ async function handleStartLocalAuth(): Promise<StartResponse> {
     loopbackCallbackPath: CLAUDE_LOOPBACK_CALLBACK_PATH,
   });
 
-  pendingFlows.set(flow.state, { status: "pending", createdAt: Date.now() });
+  pendingFlows.start(flow.state, {});
 
   // The capture + token exchange happen inside `completion`; persist the token
   // when it resolves and flip the flow status so the web client's status poll
@@ -154,12 +127,12 @@ async function handleStartLocalAuth(): Promise<StartResponse> {
   void flow.completion
     .then(async (result) => {
       await storeAcpClaudeToken(result.tokens.accessToken);
-      markFlow(flow.state, "connected");
+      pendingFlows.mark(flow.state, "connected");
       log.info("ACP Claude local OAuth flow connected");
     })
     .catch((err) => {
       const message = err instanceof Error ? err.message : String(err);
-      markFlow(flow.state, "error", message);
+      pendingFlows.mark(flow.state, "error", { error: message });
       log.error({ err: message }, "ACP Claude local OAuth flow failed");
     });
 
@@ -180,9 +153,7 @@ function handleStartManualAuth(): StartResponse {
   const codeChallenge = generateCodeChallenge(codeVerifier);
   const state = generateState();
 
-  pendingFlows.set(state, {
-    status: "pending",
-    createdAt: Date.now(),
+  pendingFlows.start(state, {
     codeVerifier,
     redirectUri: CLAUDE_MANUAL_REDIRECT_URI,
   });
@@ -228,7 +199,7 @@ async function handleExchange(args: RouteHandlerArgs): Promise<{ ok: true }> {
     );
   }
 
-  if (Date.now() - pending.createdAt > PENDING_FLOW_TTL_MS) {
+  if (pendingFlows.isExpired(pending)) {
     pendingFlows.delete(state);
     throw new BadRequestError(
       "Connect Claude flow expired. Restart the Connect Claude flow.",
@@ -248,7 +219,7 @@ async function handleExchange(args: RouteHandlerArgs): Promise<{ ok: true }> {
     await storeAcpClaudeToken(result.tokens.accessToken);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    markFlow(state, "error", message);
+    pendingFlows.mark(state, "error", { error: message });
     log.error({ err: message }, "ACP Claude manual OAuth flow failed");
     throw new BadRequestError(
       `Failed to exchange Claude authorization code: ${message}`,
@@ -271,21 +242,21 @@ async function handleAuthConnected(): Promise<{ connected: boolean }> {
 }
 
 function handleAuthStatus({ pathParams }: RouteHandlerArgs): {
-  status: FlowStatus;
+  status: PendingFlowStatus;
   error?: string;
 } {
   const { state } = pathParams as { state: string };
-  const flow = pendingFlows.get(state);
+  const report = pendingFlows.readStatus(state);
 
-  if (!flow) {
+  if (!report) {
     throw new NotFoundError(
       "No active Claude auth flow for the given state. Restart the connect flow.",
     );
   }
 
-  return flow.error
-    ? { status: flow.status, error: flow.error }
-    : { status: flow.status };
+  return report.error !== undefined
+    ? { status: report.status, error: report.error }
+    : { status: report.status };
 }
 
 // ---------------------------------------------------------------------------

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

@@ -46,8 +46,6 @@ function canonicalizeConfirmDecision(params: {
 function handleConfirm({ body }: RouteHandlerArgs) {
   const requestId = body?.requestId as string | undefined;
   const decision = body?.decision as string | undefined;
-  const selectedPattern = body?.selectedPattern as string | undefined;
-  const selectedScope = body?.selectedScope as string | undefined;
 
   if (!requestId || typeof requestId !== "string") {
     throw new BadRequestError("requestId is required");
@@ -107,8 +105,6 @@ function handleConfirm({ body }: RouteHandlerArgs) {
     requestId,
     effectiveDecision as UserDecision,
     {
-      selectedPattern,
-      selectedScope,
       emissionContext: { source: "button" },
     },
   );
@@ -342,14 +338,6 @@ export const ROUTES: RouteDefinition[] = [
     requestBody: z.object({
       requestId: z.string().describe("Pending interaction request ID"),
       decision: z.string().describe("One of: allow, deny"),
-      selectedPattern: z
-        .string()
-        .describe("Allowlist pattern for persistent decisions")
-        .optional(),
-      selectedScope: z
-        .string()
-        .describe("Scope for persistent decisions")
-        .optional(),
     }),
     responseBody: z.object({
       accepted: z.boolean(),

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

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 
+import { AVATAR_TRAITS_FILENAME } from "@vellumai/avatar-manifest";
 import { z } from "zod";
 
 import { renderCharacterAscii } from "../../avatar/ascii-renderer.js";
@@ -16,23 +17,19 @@ import {
   setImage,
 } from "../../avatar/avatar-store.js";
 import { getCharacterComponents } from "../../avatar/character-components.js";
-import { updateIdentityAvatarSection } from "../../avatar/identity-avatar.js";
 import {
-  type CharacterTraits,
-  TRAITS_FILENAME,
-  writeTraitsAndRenderAvatar,
-} from "../../avatar/traits-png-sync.js";
+  ensureAvatarRaster,
+  ensureAvatarRasterPath,
+} from "../../avatar/ensure-raster.js";
+import { updateIdentityAvatarSection } from "../../avatar/identity-avatar.js";
+import type { CharacterTraits } from "../../avatar/traits-png-sync.js";
 import { setPlatformBaseUrl } from "../../config/env.js";
 import { credentialKey } from "../../security/credential-key.js";
 import { getSecureKeyAsync } from "../../security/secure-keys.js";
 import { detectMediaType } from "../../tools/shared/filesystem/image-read.js";
 import { generateAvatarImage } from "../../tools/system/avatar-generator.js";
 import { getLogger } from "../../util/logger.js";
-import {
-  getAvatarDir,
-  getAvatarImagePath,
-  getWorkspaceDir,
-} from "../../util/platform.js";
+import { getAvatarDir, getWorkspaceDir } from "../../util/platform.js";
 import { ACTOR_PRINCIPALS, LOCAL_PRINCIPALS } from "../auth/route-policy.js";
 import { publishAvatarChanged } from "../sync/resource-sync-events.js";
 import {
@@ -259,7 +256,7 @@ function handleRemoveAvatar({ headers }: RouteHandlerArgs) {
   return { ok: true, hadAvatar };
 }
 
-function handleGetAvatar({ queryParams, body }: RouteHandlerArgs) {
+async function handleGetAvatar({ queryParams, body }: RouteHandlerArgs) {
   const format = (queryParams?.format ??
     (body as Record<string, unknown>)?.format ??
     "path") as string;
@@ -281,27 +278,17 @@ function handleGetAvatar({ queryParams, body }: RouteHandlerArgs) {
     return { exists: false };
   }
 
-  const avatarPath = getAvatarImagePath();
-
-  // For a character, the rendered PNG normally already exists on disk. Keep the
-  // existing safety net: if it's missing, re-render it from the persisted traits
-  // so the accessor still returns a raster.
-  if (state.kind === "character" && !existsSync(avatarPath) && state.traits) {
-    try {
-      writeTraitsAndRenderAvatar(state.traits);
-    } catch {
-      // Best-effort
-    }
+  // A character whose PNG is missing is regenerated on read. Path mode never
+  // loads the raster bytes.
+  if (format === "path") {
+    const path = await ensureAvatarRasterPath(state);
+    return path ? { exists: true, path } : { exists: false };
   }
-
-  if (!existsSync(avatarPath)) {
+  const raster = await ensureAvatarRaster(state);
+  if (!raster) {
     return { exists: false };
   }
-
-  if (format === "path") {
-    return { exists: true, path: avatarPath };
-  }
-  return { exists: true, base64: readFileSync(avatarPath).toString("base64") };
+  return { exists: true, base64: raster.toString("base64") };
 }
 
 function handleCharacterAscii({ queryParams, body }: RouteHandlerArgs) {
@@ -322,7 +309,7 @@ function handleCharacterAscii({ queryParams, body }: RouteHandlerArgs) {
     );
   }
 
-  const traitsPath = join(getAvatarDir(), TRAITS_FILENAME);
+  const traitsPath = join(getAvatarDir(), AVATAR_TRAITS_FILENAME);
   if (!existsSync(traitsPath)) {
     throw new BadRequestError(
       "No native character set. Use 'assistant avatar character update' first.",

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

@@ -632,7 +632,7 @@ export const ROUTES: RouteDefinition[] = [
     handler: handleBackupDestinationsList,
     summary: "List configured offsite backup destinations",
     description:
-      "Returns the current offsite destinations array, materializing the iCloud Drive default when no explicit array is configured.",
+      "Returns the current offsite destinations array. When no explicit array is configured, macOS materializes its encrypted iCloud Drive default while Windows and Linux return no implicit destination.",
     tags: ["backups"],
     responseBody: z.object({
       destinations: z.array(
@@ -654,7 +654,7 @@ export const ROUTES: RouteDefinition[] = [
     handler: handleBackupDestinationsAdd,
     summary: "Add an offsite backup destination",
     description:
-      "Appends a new destination. Materializes the iCloud default first if destinations is currently null. Errors if the path already exists.",
+      "Appends a new destination. Materializes the platform default first if destinations is currently null. Errors if the path already exists.",
     tags: ["backups"],
     requestBody: z.object({
       path: z