@vellumai/assistant 0.8.2 → 0.8.4

package/src/runtime/routes/document-comments-routes.ts

@@ -0,0 +1,287 @@
+/**
+ * Route handlers for document comment CRUD operations.
+ *
+ * Exposes comment management over HTTP, delegating to the store layer in
+ * `documents/document-comments-store.ts`.
+ */
+import { z } from "zod";
+
+import {
+  createComment,
+  deleteComment,
+  getComment,
+  listComments,
+  reopenComment,
+  resolveComment,
+  updateCommentContent,
+} from "../../documents/document-comments-store.js";
+import { getLogger } from "../../util/logger.js";
+import { broadcastMessage } from "../assistant-event-hub.js";
+import { BadRequestError, NotFoundError } from "./errors.js";
+import type { RouteDefinition } from "./types.js";
+
+const log = getLogger("document-comments-routes");
+
+// ---------------------------------------------------------------------------
+// Request schemas
+// ---------------------------------------------------------------------------
+
+const listQuerySchema = z.object({
+  status: z
+    .enum(["open", "resolved", "all"])
+    .default("all")
+    .describe("Filter by comment status"),
+});
+
+const createBodySchema = z.object({
+  content: z.string().min(1).describe("Comment text content"),
+  author: z.literal("user").optional().default("user").describe("Comment author"),
+  anchorStart: z
+    .number()
+    .nullable()
+    .optional()
+    .describe("Selection start offset"),
+  anchorEnd: z.number().nullable().optional().describe("Selection end offset"),
+  anchorText: z
+    .string()
+    .nullable()
+    .optional()
+    .describe("Anchored text snippet"),
+  parentCommentId: z
+    .string()
+    .nullable()
+    .optional()
+    .describe("Parent comment ID for replies"),
+  conversationId: z.string().describe("Owning conversation ID"),
+});
+
+const updateBodySchema = z
+  .object({
+    status: z
+      .enum(["open", "resolved"])
+      .optional()
+      .describe("New comment status"),
+    content: z.string().min(1).optional().describe("Updated comment text"),
+    resolvedBy: z.string().optional().describe("Who resolved the comment"),
+  })
+  .refine((data) => data.status !== undefined || data.content !== undefined, {
+    message: "At least one of status or content must be provided",
+  });
+
+// ---------------------------------------------------------------------------
+// Route definitions
+// ---------------------------------------------------------------------------
+
+export const ROUTES: RouteDefinition[] = [
+  {
+    operationId: "listDocumentComments",
+    endpoint: "documents/:id/comments",
+    method: "GET",
+    policyKey: "documents",
+    requirePolicyEnforcement: true,
+    summary: "List comments for a document",
+    description:
+      "Return comments for a document, optionally filtered by status.",
+    tags: ["documents"],
+    queryParams: [
+      {
+        name: "status",
+        schema: { type: "string", enum: ["open", "resolved", "all"] },
+        description: "Filter by comment status (default: all)",
+      },
+    ],
+    responseBody: z.object({
+      comments: z.array(z.unknown()).describe("Comment records"),
+    }),
+    handler: ({ pathParams, queryParams }) => {
+      const parsed = listQuerySchema.safeParse(queryParams ?? {});
+      if (!parsed.success) {
+        throw new BadRequestError(parsed.error.issues[0].message);
+      }
+      const { status } = parsed.data;
+      const comments = listComments(pathParams!.id, { status });
+      return { comments };
+    },
+  },
+
+  {
+    operationId: "createDocumentComment",
+    endpoint: "documents/:id/comments",
+    method: "POST",
+    policyKey: "documents",
+    requirePolicyEnforcement: true,
+    summary: "Create a comment on a document",
+    description: "Add a new comment to a document.",
+    tags: ["documents"],
+    requestBody: createBodySchema,
+    responseBody: z.object({
+      id: z.string(),
+      surfaceId: z.string(),
+      conversationId: z.string(),
+      author: z.string(),
+      content: z.string(),
+      status: z.string(),
+      createdAt: z.number(),
+      updatedAt: z.number(),
+    }),
+    handler: ({ pathParams, body }) => {
+      const parsed = createBodySchema.safeParse(body ?? {});
+      if (!parsed.success) {
+        throw new BadRequestError(parsed.error.issues[0].message);
+      }
+      const {
+        content,
+        author,
+        anchorStart,
+        anchorEnd,
+        anchorText,
+        parentCommentId,
+        conversationId,
+      } = parsed.data;
+      const comment = createComment({
+        surfaceId: pathParams!.id,
+        conversationId,
+        author,
+        content,
+        anchorStart,
+        anchorEnd,
+        anchorText,
+        parentCommentId,
+      });
+      broadcastMessage(
+        {
+          type: "document_comment_created",
+          conversationId,
+          surfaceId: pathParams!.id,
+          comment: {
+            id: comment.id,
+            surfaceId: comment.surfaceId,
+            author: comment.author,
+            content: comment.content,
+            anchorStart: comment.anchorStart ?? undefined,
+            anchorEnd: comment.anchorEnd ?? undefined,
+            anchorText: comment.anchorText ?? undefined,
+            parentCommentId: comment.parentCommentId ?? undefined,
+            status: comment.status,
+            createdAt: comment.createdAt,
+            updatedAt: comment.updatedAt,
+          },
+        },
+        conversationId,
+      );
+      log.info(
+        { id: comment.id, surfaceId: pathParams!.id },
+        "Created document comment via HTTP",
+      );
+      return comment;
+    },
+  },
+
+  {
+    operationId: "updateDocumentComment",
+    endpoint: "documents/:id/comments/:commentId",
+    method: "PATCH",
+    policyKey: "documents",
+    requirePolicyEnforcement: true,
+    summary: "Update a document comment",
+    description: "Update the status or content of a comment.",
+    tags: ["documents"],
+    requestBody: updateBodySchema,
+    responseBody: z.object({
+      id: z.string(),
+      surfaceId: z.string(),
+      content: z.string(),
+      status: z.string(),
+      updatedAt: z.number(),
+    }),
+    handler: ({ pathParams, body }) => {
+      const parsed = updateBodySchema.safeParse(body ?? {});
+      if (!parsed.success) {
+        throw new BadRequestError(parsed.error.issues[0].message);
+      }
+      const { status, content, resolvedBy } = parsed.data;
+      const commentId = pathParams!.commentId;
+
+      const existing = getComment(commentId);
+      if (!existing || existing.surfaceId !== pathParams!.id) {
+        throw new NotFoundError("Comment not found");
+      }
+
+      if (status === "resolved") {
+        resolveComment(commentId, resolvedBy ?? "user");
+        broadcastMessage(
+          {
+            type: "document_comment_resolved",
+            conversationId: existing.conversationId,
+            surfaceId: pathParams!.id,
+            commentId,
+            resolvedBy: resolvedBy ?? "user",
+          },
+          existing.conversationId,
+        );
+      } else if (status === "open") {
+        reopenComment(commentId);
+        broadcastMessage(
+          {
+            type: "document_comment_reopened",
+            conversationId: existing.conversationId,
+            surfaceId: pathParams!.id,
+            commentId,
+          },
+          existing.conversationId,
+        );
+      }
+
+      if (content !== undefined) {
+        updateCommentContent(commentId, content);
+      }
+
+      const updated = getComment(commentId);
+      if (!updated) {
+        throw new NotFoundError("Comment not found after update");
+      }
+
+      log.info(
+        { id: commentId, surfaceId: pathParams!.id },
+        "Updated document comment via HTTP",
+      );
+      return updated;
+    },
+  },
+
+  {
+    operationId: "deleteDocumentComment",
+    endpoint: "documents/:id/comments/:commentId",
+    method: "DELETE",
+    policyKey: "documents",
+    requirePolicyEnforcement: true,
+    summary: "Delete a document comment",
+    description: "Permanently delete a comment.",
+    tags: ["documents"],
+    responseBody: z.object({
+      success: z.literal(true),
+    }),
+    handler: ({ pathParams }) => {
+      const commentId = pathParams!.commentId;
+      const existing = getComment(commentId);
+      if (!existing || existing.surfaceId !== pathParams!.id) {
+        throw new NotFoundError("Comment not found");
+      }
+      deleteComment(commentId);
+      broadcastMessage(
+        {
+          type: "document_comment_deleted",
+          conversationId: existing.conversationId,
+          surfaceId: pathParams!.id,
+          commentId,
+        },
+        existing.conversationId,
+      );
+      log.info(
+        { id: commentId, surfaceId: pathParams!.id },
+        "Deleted document comment via HTTP",
+      );
+      return { success: true as const };
+    },
+  },
+];

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

@@ -7,6 +7,7 @@
 import { z } from "zod";
 
 import {
+  addDocumentConversation,
   getDocumentById,
   getDocumentsForConversation,
   saveDocument,
@@ -181,6 +182,38 @@ export const ROUTES: RouteDefinition[] = [
     },
   },
 
+  {
+    operationId: "linkDocumentConversation",
+    endpoint: "documents/:id/conversations",
+    method: "POST",
+    policyKey: "documents",
+    requirePolicyEnforcement: true,
+    summary: "Link a document to a conversation",
+    description:
+      "Associate a document with a conversation so the assistant sees it as context.",
+    tags: ["documents"],
+    requestBody: z.object({
+      conversationId: z.string().describe("Conversation to link"),
+    }),
+    responseBody: z.object({ success: z.literal(true) }),
+    handler: ({ pathParams, body }) => {
+      const { conversationId } = (body ?? {}) as { conversationId?: string };
+      if (!conversationId) {
+        throw new BadRequestError("conversationId is required");
+      }
+      const doc = getDocumentById(pathParams!.id);
+      if (!doc) {
+        throw new NotFoundError("Document not found");
+      }
+      addDocumentConversation(pathParams!.id, conversationId);
+      log.info(
+        { surfaceId: pathParams!.id, conversationId },
+        "Linked document to conversation",
+      );
+      return { success: true as const };
+    },
+  },
+
   {
     operationId: "exportDocumentPDF",
     endpoint: "documents/:id/pdf",

package/src/runtime/routes/home-feed-routes.ts

@@ -29,6 +29,7 @@ import {
   suggestedPromptSchema,
 } from "../../home/feed-types.js";
 import { patchFeedItemStatus, readHomeFeed } from "../../home/feed-writer.js";
+import { getPersonalizedGreeting } from "../../home/home-greeting.js";
 import { getSuggestedPrompts } from "../../home/suggested-prompts.js";
 import {
   addMessage,
@@ -123,14 +124,16 @@ export async function handleGetHomeFeed({
   const filtered = feed.items;
 
   const now = new Date();
+
+  const personalizedGreeting = getPersonalizedGreeting();
+  const suggestedPrompts = await getSuggestedPrompts();
+
   const contextBanner = {
-    greeting: computeGreeting(now),
+    greeting: personalizedGreeting ?? computeGreeting(now),
     timeAwayLabel: formatRelativeTime(timeAwaySeconds),
     newCount: filtered.filter((i) => i.status === "new").length,
   };
 
-  const suggestedPrompts = await getSuggestedPrompts();
-
   log.debug(
     {
       timeAwayBucket: timeAwayBucket(timeAwaySeconds),

package/src/runtime/routes/host-app-control-routes.ts

@@ -105,7 +105,7 @@ function handleHostAppControlResult({ body, headers }: RouteHandlerArgs) {
     });
   }
 
-  const interaction = pendingInteractions.resolve(requestId)!;
+  const interaction = pendingInteractions.resolve(requestId, "answered")!;
   const conversation = findConversation(interaction.conversationId);
   if (!conversation) {
     return { accepted: true };

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

@@ -10,6 +10,7 @@ import {
   markTargetInvalidated,
   publishCdpEvent,
 } from "../../browser-session/events.js";
+import { clearPinnedTabByTabId } from "../../tools/browser/pinned-tabs.js";
 import {
   enforceSameActorOrThrow,
   SAME_ACTOR_FORBIDDEN_DESCRIPTION,
@@ -149,7 +150,7 @@ export function resolveHostBrowserResultByRequestId(
   const normalizedContent = typeof content === "string" ? content : "";
   const normalizedIsError = typeof isError === "boolean" ? isError : false;
 
-  const interaction = pendingInteractions.resolve(requestId);
+  const interaction = pendingInteractions.resolve(requestId, "answered");
   interaction?.rpcResolve?.({
     content: normalizedContent,
     isError: normalizedIsError,
@@ -239,6 +240,12 @@ export function resolveHostBrowserSessionInvalidated(frame: {
       targetId,
       typeof reason === "string" ? reason : undefined,
     );
+    // Clear any pinned-tab entries pointing at this target so that
+    // subsequent `navigate` calls don't try to route to a dead tab.
+    // Without this, a user closing the pinned tab manually would see
+    // their next browser command fail with a `cdp_session_not_found`
+    // until the daemon process restarts.
+    clearPinnedTabByTabId(targetId);
   }
 
   return { ok: true };

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

@@ -11,10 +11,12 @@ import { getCpuLimit, getIsPlatform } from "../../config/env-registry.js";
 import { parseIdentityFields } from "../../daemon/handlers/identity.js";
 import { getProfilerRuntimeStatus } from "../../daemon/profiler-run-store.js";
 import { getMaxMigrationVersion } from "../../memory/migrations/registry.js";
+import { getCesClient } from "../../security/secure-keys.js";
 import {
   getDiskUsageInfo,
   parseK8sMemoryBytes,
 } from "../../util/disk-usage.js";
+import { getLogger } from "../../util/logger.js";
 import { getWorkspacePromptPath } from "../../util/platform.js";
 import { APP_VERSION } from "../../version.js";
 import { resolveHatchedAtReadOnly } from "../../workspace/hatched-date.js";
@@ -323,6 +325,8 @@ function getDetailedHealth() {
     // Profiler status is non-critical — omit on error
   }
 
+  const cesClient = getCesClient();
+
   return {
     status: "healthy",
     timestamp: new Date().toISOString(),
@@ -335,6 +339,9 @@ function getDetailedHealth() {
       lastWorkspaceMigrationId:
         getLastWorkspaceMigrationId(WORKSPACE_MIGRATIONS),
     },
+    ces: {
+      connected: cesClient?.isReady() ?? false,
+    },
     ...(profiler ? { profiler } : {}),
   };
 }
@@ -344,6 +351,15 @@ export function handleDetailedHealth(): Response {
 }
 
 export function handleReadyz(): Response {
+  const cesClient = getCesClient();
+  if (!cesClient?.isReady()) {
+    // TODO: Return 503 once we confirm via logs that this won't cause
+    // regressions in the K8s readinessProbe.
+    getLogger("health").warn(
+      { reason: cesClient ? "ces_not_ready" : "ces_unavailable" },
+      "CES not ready — pod would be unready if 503 were enabled",
+    );
+  }
   return Response.json({ status: "ok" });
 }
 
@@ -423,6 +439,10 @@ const profilerStatusSchema = z.object({
   lastCompletedRun: profilerLastCompletedRunSchema.nullable(),
 });
 
+const cesHealthSchema = z.object({
+  connected: z.boolean(),
+});
+
 const detailedHealthSchema = z.object({
   status: z.string(),
   timestamp: z.string(),
@@ -431,6 +451,7 @@ const detailedHealthSchema = z.object({
   memory: z.object({}).passthrough(),
   cpu: z.object({}).passthrough(),
   migrations: z.object({}).passthrough(),
+  ces: cesHealthSchema,
   profiler: profilerStatusSchema.optional(),
 });