@vellumai/assistant 0.10.4 → 0.10.5-dev.202607022329.d89bf2f

package/src/persistence/a2a-invite-store.ts

@@ -0,0 +1,205 @@
+/**
+ * Store for daemon-local A2A invites.
+ *
+ * A2A invites bind a placeholder assistant contact to a shareable token used
+ * for link-based peer-assistant connection. Each invite carries a SHA-256
+ * hashed token — the raw token is returned exactly once at creation time and
+ * never stored.
+ */
+
+import { randomUUID } from "node:crypto";
+
+import {
+  generateInviteToken,
+  hashInviteToken,
+} from "@vellumai/gateway-client";
+import { and, eq } from "drizzle-orm";
+
+import { getDb } from "./db-connection.js";
+import { a2aInvites } from "./schema/a2a.js";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export type A2aInviteStatus = "active" | "redeemed" | "revoked" | "expired";
+
+export interface A2aInvite {
+  id: string;
+  tokenHash: string;
+  contactId: string;
+  maxUses: number;
+  useCount: number;
+  expiresAt: number;
+  status: A2aInviteStatus;
+  redeemedByExternalUserId: string | null;
+  redeemedAt: number | null;
+  createdAt: number;
+  updatedAt: number;
+}
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+const DEFAULT_EXPIRY_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function rowToInvite(row: typeof a2aInvites.$inferSelect): A2aInvite {
+  return { ...row, status: row.status as A2aInviteStatus };
+}
+
+function findByTokenHash(tokenHash: string): A2aInvite | null {
+  const db = getDb();
+  const row = db
+    .select()
+    .from(a2aInvites)
+    .where(eq(a2aInvites.tokenHash, tokenHash))
+    .get();
+  return row ? rowToInvite(row) : null;
+}
+
+/**
+ * Transition an invite's status to 'expired' in storage. Safe to call even if
+ * the invite is already expired — the WHERE clause scopes the update to
+ * 'active' rows so it becomes a no-op in that case.
+ */
+function markExpired(inviteId: string): void {
+  const db = getDb();
+  db.update(a2aInvites)
+    .set({ status: "expired", updatedAt: Date.now() })
+    .where(and(eq(a2aInvites.id, inviteId), eq(a2aInvites.status, "active")))
+    .run();
+}
+
+/**
+ * Increment an invite's use count and record redemption metadata. Returns
+ * `true` if the use was recorded, or `false` if the invite was concurrently
+ * revoked/expired (the WHERE clause constrains to `status = 'active'` so a
+ * stale write is impossible).
+ */
+function recordUse(params: {
+  inviteId: string;
+  redeemedByExternalUserId: string;
+}): boolean {
+  const db = getDb();
+  const now = Date.now();
+
+  const invite = db
+    .select()
+    .from(a2aInvites)
+    .where(eq(a2aInvites.id, params.inviteId))
+    .get();
+
+  if (!invite) {
+    return false;
+  }
+
+  const newUseCount = invite.useCount + 1;
+  const newStatus = newUseCount >= invite.maxUses ? "redeemed" : "active";
+
+  db.update(a2aInvites)
+    .set({
+      useCount: newUseCount,
+      status: newStatus,
+      redeemedByExternalUserId: params.redeemedByExternalUserId,
+      redeemedAt: now,
+      updatedAt: now,
+    })
+    .where(and(eq(a2aInvites.id, invite.id), eq(a2aInvites.status, "active")))
+    .run();
+
+  // Re-read to confirm the update took effect (the WHERE clause constrains
+  // to status = 'active', so a concurrent revoke/expire would prevent it).
+  const updated = db
+    .select({ useCount: a2aInvites.useCount })
+    .from(a2aInvites)
+    .where(eq(a2aInvites.id, invite.id))
+    .get();
+
+  return !!updated && updated.useCount === newUseCount;
+}
+
+// ---------------------------------------------------------------------------
+// createA2aInvite
+// ---------------------------------------------------------------------------
+
+export function createA2aInvite(params: {
+  contactId: string;
+  maxUses?: number;
+  expiresInMs?: number;
+}): { invite: A2aInvite; rawToken: string } {
+  const db = getDb();
+  const now = Date.now();
+  const rawToken = generateInviteToken();
+
+  const row = {
+    id: randomUUID(),
+    tokenHash: hashInviteToken(rawToken),
+    contactId: params.contactId,
+    maxUses: params.maxUses ?? 1,
+    useCount: 0,
+    expiresAt: now + (params.expiresInMs ?? DEFAULT_EXPIRY_MS),
+    status: "active" as const,
+    redeemedByExternalUserId: null,
+    redeemedAt: null,
+    createdAt: now,
+    updatedAt: now,
+  };
+
+  db.insert(a2aInvites).values(row).run();
+
+  return { invite: rowToInvite(row), rawToken };
+}
+
+// ---------------------------------------------------------------------------
+// claimA2aInvite — validate + consume an A2A invite token
+// ---------------------------------------------------------------------------
+
+export function claimA2aInvite(params: {
+  token: string;
+  redeemedByExternalUserId: string;
+}): { claimed: boolean; invite: A2aInvite | null; error?: string } {
+  const tokenHash = hashInviteToken(params.token);
+  const invite = findByTokenHash(tokenHash);
+
+  if (!invite) {
+    return { claimed: false, invite: null, error: "not_found" };
+  }
+
+  // Idempotency: if already redeemed by the same acceptor, return success
+  if (invite.status === "redeemed") {
+    if (invite.redeemedByExternalUserId === params.redeemedByExternalUserId) {
+      return { claimed: true, invite };
+    }
+    return { claimed: false, invite, error: "already_redeemed_by_other" };
+  }
+
+  if (invite.status !== "active") {
+    return { claimed: false, invite, error: "not_found" };
+  }
+
+  if (Date.now() >= invite.expiresAt) {
+    markExpired(invite.id);
+    return { claimed: false, invite, error: "expired" };
+  }
+
+  if (invite.useCount >= invite.maxUses) {
+    return { claimed: false, invite, error: "already_redeemed" };
+  }
+
+  const recorded = recordUse({
+    inviteId: invite.id,
+    redeemedByExternalUserId: params.redeemedByExternalUserId,
+  });
+
+  if (!recorded) {
+    return { claimed: false, invite, error: "not_found" };
+  }
+
+  // Re-read to get updated state
+  return { claimed: true, invite: findByTokenHash(tokenHash) };
+}

package/src/persistence/attachments-store.ts

@@ -20,6 +20,11 @@ import { basename, dirname, extname, join } from "node:path";
 import { eq } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
+import {
+  jpegFilenameFor,
+  normalizeImageBase64,
+  normalizeImageBytes,
+} from "../util/image-conversion.js";
 import { getLogger } from "../util/logger.js";
 import { getWorkspaceDir } from "../util/platform.js";
 import { getConversationAttachmentsDirPath } from "./conversation-directories.js";
@@ -98,6 +103,7 @@ interface AttachmentRow {
 function getAttachmentRow(attachmentId: string): AttachmentRow | null {
   return (
     rawGet<AttachmentRow>(
+      "attachments:getAttachmentRow",
       `SELECT
          id,
          original_filename AS originalFilename,
@@ -122,6 +128,7 @@ function getMessageConversationContext(
 ): { conversationId: string; conversationCreatedAt: number } | null {
   return (
     rawGet<{ conversationId: string; conversationCreatedAt: number }>(
+      "attachments:getMessageConversationContext",
       `SELECT
          m.conversation_id AS conversationId,
          c.created_at AS conversationCreatedAt
@@ -135,6 +142,7 @@ function getMessageConversationContext(
 
 function listLinkedConversationIds(attachmentId: string): string[] {
   return rawAll<{ conversationId: string }>(
+    "attachments:listLinkedConversationIds",
     `SELECT DISTINCT m.conversation_id AS conversationId
      FROM message_attachments ma
      JOIN messages m ON m.id = ma.message_id
@@ -165,6 +173,7 @@ function cloneAttachmentRow(row: AttachmentRow): AttachmentRow {
 
   if (row.sourcePath) {
     rawRun(
+      "attachments:cloneAttachmentRow",
       `UPDATE attachments SET source_path = ? WHERE id = ?`,
       row.sourcePath,
       clonedId,
@@ -202,6 +211,7 @@ function persistAttachmentFilePath(
 ): void {
   if (sourcePath) {
     rawRun(
+      "attachments:persistFilePath:withSource",
       `UPDATE attachments
        SET file_path = ?, data_base64 = '', source_path = COALESCE(source_path, ?)
        WHERE id = ?`,
@@ -213,6 +223,7 @@ function persistAttachmentFilePath(
   }
 
   rawRun(
+    "attachments:persistFilePath:plain",
     `UPDATE attachments SET file_path = ?, data_base64 = '' WHERE id = ?`,
     targetPath,
     attachmentId,
@@ -236,7 +247,11 @@ function materializeAttachmentIntoConversation(
     dirname(row.filePath) === attachDir
   ) {
     if (row.dataBase64) {
-      rawRun(`UPDATE attachments SET data_base64 = '' WHERE id = ?`, row.id);
+      rawRun(
+        "attachments:materialize:clearData",
+        `UPDATE attachments SET data_base64 = '' WHERE id = ?`,
+        row.id,
+      );
     }
     return;
   }
@@ -518,7 +533,8 @@ export function validateAttachmentUpload(
 /**
  * Write raw bytes to the staging directory and register as a file-backed
  * attachment. Used by the multipart/form-data and application/octet-stream
- * upload paths.
+ * upload paths. HEIF/HEIC images are stored as JPEG masters so every client
+ * surface can render them; other formats are stored verbatim.
  *
  * @param filename  Original filename from the client
  * @param mimeType  MIME type of the file
@@ -530,20 +546,26 @@ export function uploadAttachmentFromBytes(
   mimeType: string,
   bytes: Uint8Array,
 ): StoredAttachment {
+  let norm = normalizeImageBytes(mimeType, bytes);
+  if (norm.converted && norm.bytes.length > MAX_UPLOAD_BYTES) {
+    norm = { mimeType, bytes, converted: false };
+  }
+  const storedFilename = norm.converted ? jpegFilenameFor(filename) : filename;
+
   const dir = join(getWorkspaceDir(), "data", "attachments");
   mkdirSync(dir, { recursive: true });
 
-  const sanitized = filename.replace(/[^a-zA-Z0-9._-]/g, "_");
+  const sanitized = storedFilename.replace(/[^a-zA-Z0-9._-]/g, "_");
   const stagingFilename = `${Date.now()}-${uuid().slice(0, 8)}-${sanitized}`;
   const stagedPath = join(dir, stagingFilename);
 
-  writeFileSync(stagedPath, bytes);
+  writeFileSync(stagedPath, norm.bytes);
 
   return uploadFileBackedAttachment(
-    filename,
-    mimeType,
+    storedFilename,
+    norm.mimeType,
     stagedPath,
-    bytes.length,
+    norm.bytes.length,
   );
 }
 
@@ -583,7 +605,12 @@ export function uploadFileBackedAttachment(
     })
     .run();
 
-  rawRun(`UPDATE attachments SET source_path = ? WHERE id = ?`, filePath, id);
+  rawRun(
+    "attachments:uploadFileBacked:sourcePath",
+    `UPDATE attachments SET source_path = ? WHERE id = ?`,
+    filePath,
+    id,
+  );
 
   return {
     id,
@@ -621,6 +648,7 @@ export function getSourcePathsForAttachments(
   if (attachmentIds.length === 0) return new Map();
   const placeholders = attachmentIds.map(() => "?").join(", ");
   const rows = rawAll<{ id: string; source_path: string }>(
+    "attachments:getSourcePaths",
     `SELECT id, source_path FROM attachments WHERE id IN (${placeholders}) AND source_path IS NOT NULL`,
     ...attachmentIds,
   );
@@ -638,6 +666,7 @@ export function getFilePathBySourcePath(
 ): string | null {
   try {
     const row = rawGet<{ file_path: string | null }>(
+      "attachments:getFilePathBySourcePath",
       `SELECT a.file_path FROM attachments a
        JOIN message_attachments ma ON ma.attachment_id = a.id
        JOIN messages m ON m.id = ma.message_id
@@ -703,13 +732,45 @@ function validateAttachmentPayload(
   return sizeBytes;
 }
 
+/**
+ * HEIF/HEIC payloads are stored as JPEG masters (filename extension
+ * rewritten) so every client surface can render them; anything else — and any
+ * conversion whose output would break the upload size limit — passes through
+ * verbatim.
+ */
+function normalizeUploadedImageBase64(
+  filename: string,
+  mimeType: string,
+  dataBase64: string,
+): { filename: string; mimeType: string; dataBase64: string } {
+  const norm = normalizeImageBase64(mimeType, dataBase64);
+  if (
+    !norm.converted ||
+    computeSizeBytesFromBase64(norm.dataBase64) > MAX_UPLOAD_BYTES
+  ) {
+    return { filename, mimeType, dataBase64 };
+  }
+  return {
+    filename: jpegFilenameFor(filename),
+    mimeType: norm.mimeType,
+    dataBase64: norm.dataBase64,
+  };
+}
+
 export function uploadAttachment(
   filename: string,
   mimeType: string,
   dataBase64: string,
   sourcePath?: string,
 ): StoredAttachment {
-  const sizeBytes = validateAttachmentPayload(dataBase64);
+  validateAttachmentPayload(dataBase64);
+
+  ({ filename, mimeType, dataBase64 } = normalizeUploadedImageBase64(
+    filename,
+    mimeType,
+    dataBase64,
+  ));
+  const sizeBytes = computeSizeBytesFromBase64(dataBase64);
 
   const db = getDb();
   const now = Date.now();
@@ -731,6 +792,7 @@ export function uploadAttachment(
 
   if (sourcePath) {
     rawRun(
+      "attachments:uploadAttachment:sourcePath",
       `UPDATE attachments SET source_path = ? WHERE id = ?`,
       sourcePath,
       record.id,
@@ -754,8 +816,26 @@ export function attachInlineAttachmentToMessage(
   filename: string,
   mimeType: string,
   dataBase64: string,
-  options?: { sourcePath?: string; skipSizeLimit?: boolean },
+  options?: {
+    sourcePath?: string;
+    skipSizeLimit?: boolean;
+    /**
+     * Store HEIF/HEIC content as a JPEG master (with the filename extension
+     * rewritten) so every client surface can render it. User-sourced ingress
+     * opts in; assistant-produced attachments are stored verbatim — if the
+     * assistant deliberately emits a HEIC, rewriting it would be wrong.
+     */
+    normalizeImage?: boolean;
+  },
 ): StoredAttachment {
+  if (options?.normalizeImage) {
+    ({ filename, mimeType, dataBase64 } = normalizeUploadedImageBase64(
+      filename,
+      mimeType,
+      dataBase64,
+    ));
+  }
+
   const sizeBytes = validateAttachmentPayload(dataBase64, {
     skipSizeLimit: options?.skipSizeLimit,
   });
@@ -794,6 +874,7 @@ export function attachInlineAttachmentToMessage(
 
   if (options?.sourcePath) {
     rawRun(
+      "attachments:attachInline:sourcePath",
       `UPDATE attachments SET source_path = ? WHERE id = ?`,
       options.sourcePath,
       id,
@@ -854,6 +935,7 @@ export function attachFileBackedAttachmentToMessage(
     .run();
 
   rawRun(
+    "attachments:attachFileBacked:source",
     `UPDATE attachments SET source_path = ? WHERE id = ?`,
     sourceFilePath,
     id,
@@ -1098,6 +1180,7 @@ export function deleteOrphanAttachments(candidateIds: string[]): number {
   // Identify truly orphaned attachment IDs first (not referenced by any message)
   const placeholders = candidateIds.map(() => "?").join(", ");
   const orphanIds = rawAll<{ id: string }>(
+    "attachments:deleteOrphan:select",
     `SELECT id FROM attachments WHERE id IN (${placeholders}) AND id NOT IN (SELECT attachment_id FROM message_attachments)`,
     ...candidateIds,
   ).map((row) => row.id);
@@ -1119,6 +1202,7 @@ export function deleteOrphanAttachments(candidateIds: string[]): number {
   // remain intact alongside their DB rows, so nothing is left inconsistent.
   const orphanPlaceholders = orphanIds.map(() => "?").join(", ");
   const deletedCount = rawRun(
+    "attachments:deleteOrphan:delete",
     `DELETE FROM attachments WHERE id IN (${orphanPlaceholders})`,
     ...orphanIds,
   );

package/src/persistence/checkpoints.ts

@@ -63,3 +63,48 @@ export function resetMessageCursorCheckpoint(
     messageId: "",
   });
 }
+
+/**
+ * Completion sentinel for the messages lexical-index backfill. Set once the
+ * backfill has drained the entire `messages` table into the Qdrant lexical
+ * index (`messages_lexical`); cleared on a `force` re-run.
+ *
+ * Lives here — in `persistence/` — so it is the single source of truth for the
+ * backfill handler (plugin layer, which writes it) AND the message-search read
+ * sites (persistence + plugin layers, which gate the read backend on it).
+ * Keeping the key and its reader here lets `conversation-queries.ts` (also
+ * `persistence/`) read it without a persistence -> plugin import.
+ */
+export const LEXICAL_BACKFILL_COMPLETE_KEY =
+  "lexical:messages:backfill_complete";
+
+/**
+ * True once the messages lexical-index backfill has fully drained on this
+ * instance.
+ *
+ * Gates two things: the one-time startup auto-enqueue (skip when already
+ * complete) and — critically — the message-search read backend. An upgraded
+ * instance whose backfill has not finished must keep reading from SQLite FTS,
+ * because a `qdrant`-backed read against the still-filling `messages_lexical`
+ * collection returns an empty result (not a throw), so the Qdrant-error degrade
+ * path never fires and content search would silently return nothing. Switch
+ * reads to Qdrant only once this marker confirms the index is fully populated.
+ */
+export function isLexicalBackfillComplete(): boolean {
+  return getMemoryCheckpoint(LEXICAL_BACKFILL_COMPLETE_KEY) === "1";
+}
+
+/**
+ * Clear the lexical-backfill completion sentinel so {@link
+ * isLexicalBackfillComplete} reads false until a run re-marks it.
+ *
+ * Called when a `force` re-index is requested — both at enqueue time (so reads
+ * fall back to SQLite FTS the instant the rebuild is queued, rather than serving
+ * from a stale/emptying `messages_lexical` collection in the window before the
+ * worker claims the job) and again inside the backfill handler (idempotent).
+ * Co-located with the key and its reader here so callers clear it without
+ * re-declaring the key string.
+ */
+export function clearLexicalBackfillComplete(): void {
+  deleteMemoryCheckpoint(LEXICAL_BACKFILL_COMPLETE_KEY);
+}