@vellumai/assistant 0.6.2 → 0.6.4

package/src/memory/migrations/219-oauth-providers-token-exchange-body-format.ts

@@ -0,0 +1,15 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+export function migrateOAuthProvidersTokenExchangeBodyFormat(
+  database: DrizzleDb,
+): void {
+  const raw = getSqliteFrom(database);
+  try {
+    raw.exec(
+      /*sql*/ `ALTER TABLE oauth_providers ADD COLUMN token_exchange_body_format TEXT NOT NULL DEFAULT 'form'`,
+    );
+  } catch {
+    // Column already exists — nothing to do.
+  }
+}

package/src/memory/migrations/220-normalize-user-file-by-principal.ts

@@ -0,0 +1,190 @@
+import { computeUserFileBaseSlug } from "../../contacts/contact-store.js";
+import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+import { withCrashRecovery } from "./validate-migration-state.js";
+
+/**
+ * Reverse is a no-op. This migration only consolidates `user_file` across
+ * contacts sharing the same `principal_id`; the pre-migration split values
+ * cannot be reconstructed after normalization, and no schema changes.
+ */
+export function downNormalizeUserFileByPrincipal(_database: DrizzleDb): void {
+  /* no-op */
+}
+
+/**
+ * Heuristic: does `userFile` look like an auto-incremented persona slug?
+ *
+ * `generateUserFileSlug` appends `-<N>.md` where N is any positive integer
+ * (the loop is unbounded, so a very dense principal space could reach 4+
+ * digits). Matching is anchored to the end so a slug that happens to contain
+ * digits earlier (e.g. `alex-2024.md` for display name "Alex 2024") is not
+ * affected.
+ *
+ * The final-integer suffix also matches year-like or date-like names
+ * (`-2025.md`, `-2025-04-13.md` via the trailing `-13.md`). Those must NOT
+ * be classified as auto-increments, so we exclude any filename that ends
+ * with a date-shaped tail: `-YYYY.md`, `-YYYY-MM.md`, or `-YYYY-MM-DD.md`
+ * where YYYY is a 4-digit year starting with 19, 20, or 21. A counter that
+ * happens to fall in that range (e.g. `-1999.md`) is indistinguishable from
+ * a year by filename alone, so we conservatively treat it as non-auto.
+ *
+ * Month/day segments must be 2 digits (ISO style) to discriminate them from
+ * single-digit collision counters: `generateUserFileSlug` emits `-2.md`,
+ * `-3.md`, etc. without leading zeros, so `alex-2025-2.md` is a counter on
+ * base `alex-2025.md` — not a date — and must remain classified as auto.
+ *
+ * Filename-only classification is still ambiguous at the margins: a display
+ * name like "Alex 2025 4" legitimately produces `alex-2025-4.md` as a base
+ * slug, which looks identical to a year-prefixed counter. When the caller can
+ * supply the row's display name, we disambiguate by recomputing the expected
+ * base slug: if it matches the filename, the name is a base slug and we
+ * classify as non-auto. This closes the only remaining false-positive hole.
+ */
+const DATE_LIKE_SUFFIX = /-(19|20|21)\d{2}((-\d{2}){1,2})?\.md$/;
+const INTEGER_SUFFIX = /-\d+\.md$/;
+
+export function isAutoIncrementedUserFile(
+  userFile: string,
+  displayName?: string,
+): boolean {
+  if (DATE_LIKE_SUFFIX.test(userFile)) return false;
+  if (!INTEGER_SUFFIX.test(userFile)) return false;
+  if (displayName !== undefined) {
+    const expectedBase = `${computeUserFileBaseSlug(displayName)}.md`;
+    if (expectedBase === userFile) return false;
+  }
+  return true;
+}
+
+/**
+ * Normalize `contacts.user_file` across contact rows that share the same
+ * `principal_id`.
+ *
+ * Multiple contact rows may represent the same principal (one per channel:
+ * desktop, phone, Slack, etc.). When a new row was created for a second
+ * channel, `generateUserFileSlug(displayName)` auto-incremented to avoid a
+ * filename collision (e.g. `sidd.md` → `sidd-2.md`), even though no
+ * `sidd-2.md` file ever existed on disk. The persona resolver then silently
+ * fell back to `users/default.md` for that channel's messages — and the same
+ * slug is used for the journal directory, so the user lost per-principal
+ * continuity on every non-primary channel.
+ *
+ * This migration picks one canonical `user_file` per principal and updates
+ * every sibling row to match. Selection heuristic:
+ *
+ *   1. Prefer values that do NOT look auto-incremented (see
+ *      `isAutoIncrementedUserFile`).
+ *   2. Among those, prefer the oldest contact row (earliest `created_at`).
+ *   3. Ties broken by `id` for determinism.
+ *
+ * Skips principals where only one distinct (non-null) value exists — nothing
+ * to normalize. Principals whose contacts all have `user_file = NULL` are
+ * left untouched; the code path in `upsertContact` will populate them on the
+ * next write.
+ */
+export function migrateNormalizeUserFileByPrincipal(
+  database: DrizzleDb,
+): void {
+  withCrashRecovery(
+    database,
+    "migration_normalize_user_file_by_principal_v1",
+    () => {
+      const raw = getSqliteFrom(database);
+
+      const tableExists = raw
+        .query(
+          `SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'contacts'`,
+        )
+        .get();
+      if (!tableExists) return;
+
+      const userFileColExists = raw
+        .query(
+          `SELECT 1 FROM pragma_table_info('contacts') WHERE name = 'user_file'`,
+        )
+        .get();
+      const principalColExists = raw
+        .query(
+          `SELECT 1 FROM pragma_table_info('contacts') WHERE name = 'principal_id'`,
+        )
+        .get();
+      if (!userFileColExists || !principalColExists) return;
+
+      try {
+        raw.exec("BEGIN");
+
+        const principals = raw
+          .query(
+            /*sql*/ `
+            SELECT principal_id
+            FROM contacts
+            WHERE principal_id IS NOT NULL
+            GROUP BY principal_id
+            HAVING COUNT(DISTINCT COALESCE(user_file, '')) > 1
+          `,
+          )
+          .all() as Array<{ principal_id: string }>;
+
+        // Fetch all non-null candidates and rank in JS. The auto-increment
+        // classification is a regex that SQLite's GLOB can't express cleanly
+        // (unbounded digit count, date-pattern exclusion), and keeping the
+        // logic in one place avoids SQL/JS drift.
+        const selectCandidates = raw.prepare(
+          /*sql*/ `
+          SELECT user_file, display_name, created_at, id FROM contacts
+          WHERE principal_id = ? AND user_file IS NOT NULL
+          `,
+        );
+
+        const updateSiblings = raw.prepare(
+          /*sql*/ `
+          UPDATE contacts
+          SET user_file = ?, updated_at = ?
+          WHERE principal_id = ?
+            AND (user_file IS NULL OR user_file != ?)
+          `,
+        );
+
+        for (const { principal_id } of principals) {
+          const candidates = selectCandidates.all(principal_id) as Array<{
+            user_file: string;
+            display_name: string;
+            created_at: number;
+            id: string;
+          }>;
+          if (candidates.length === 0) continue;
+
+          candidates.sort((a, b) => {
+            const aAuto = isAutoIncrementedUserFile(a.user_file, a.display_name)
+              ? 1
+              : 0;
+            const bAuto = isAutoIncrementedUserFile(b.user_file, b.display_name)
+              ? 1
+              : 0;
+            if (aAuto !== bAuto) return aAuto - bAuto;
+            if (a.created_at !== b.created_at)
+              return a.created_at - b.created_at;
+            return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+          });
+
+          const canonical = candidates[0]!.user_file;
+          updateSiblings.run(
+            canonical,
+            Date.now(),
+            principal_id,
+            canonical,
+          );
+        }
+
+        raw.exec("COMMIT");
+      } catch (e) {
+        try {
+          raw.exec("ROLLBACK");
+        } catch {
+          /* no active transaction */
+        }
+        throw e;
+      }
+    },
+  );
+}

package/src/memory/migrations/221-conversations-archived-at.ts

@@ -0,0 +1,16 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+export function migrateConversationsArchivedAt(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  try {
+    raw.exec(
+      `ALTER TABLE conversations ADD COLUMN archived_at INTEGER DEFAULT NULL`,
+    );
+  } catch {
+    // Column already exists — nothing to do.
+  }
+  raw.exec(
+    `CREATE INDEX IF NOT EXISTS idx_conversations_archived_at ON conversations (archived_at)`,
+  );
+}

package/src/memory/migrations/index.ts

@@ -154,6 +154,18 @@ export { migrateStripThinkingFromConsolidated } from "./209-strip-thinking-from-
 export { migrateScheduleReuseConversation } from "./210-schedule-reuse-conversation.js";
 export { migrateMemoryRecallLogsQueryContext } from "./211-memory-recall-logs-query-context.js";
 export { migrateLlmRequestLogsCreatedAtIndex } from "./212-llm-request-logs-created-at-index.js";
+export { migrateOAuthProvidersScopeSeparator } from "./213-oauth-providers-scope-separator.js";
+export { migrateOAuthProvidersRefreshUrl } from "./214-oauth-providers-refresh-url.js";
+export { migrateOAuthProvidersRevoke } from "./215-oauth-providers-revoke.js";
+export { migrateOAuthProvidersTokenAuthMethodDefault } from "./216-oauth-providers-token-auth-method.js";
+export { migrateConversationHostAccess } from "./217-conversation-host-access.js";
+export { migrateOAuthProvidersLogoUrl } from "./218-oauth-providers-logo-url.js";
+export { migrateOAuthProvidersTokenExchangeBodyFormat } from "./219-oauth-providers-token-exchange-body-format.js";
+export {
+  downNormalizeUserFileByPrincipal,
+  migrateNormalizeUserFileByPrincipal,
+} from "./220-normalize-user-file-by-principal.js";
+export { migrateConversationsArchivedAt } from "./221-conversations-archived-at.js";
 export {
   MIGRATION_REGISTRY,
   type MigrationRegistryEntry,

package/src/memory/migrations/registry.ts

@@ -41,6 +41,8 @@ import { migrateAddSourceTypeColumnsDown } from "./193-add-source-type-columns.j
 import { migrateStripIntegrationPrefixFromProviderKeysDown } from "./196-strip-integration-prefix-from-provider-keys.js";
 import { migrateRenameMemoryGraphTypeValuesDown } from "./204-rename-memory-graph-type-values.js";
 import { migrateScrubCorruptedImageAttachmentsDown } from "./206-scrub-corrupted-image-attachments.js";
+import { downConversationHostAccess } from "./217-conversation-host-access.js";
+import { downNormalizeUserFileByPrincipal } from "./220-normalize-user-file-by-principal.js";
 
 export interface MigrationRegistryEntry {
   /** The checkpoint key written to memory_checkpoints on completion. */
@@ -357,6 +359,20 @@ export const MIGRATION_REGISTRY: MigrationRegistryEntry[] = [
       "Remove image attachments containing HTML error pages instead of image data",
     down: migrateScrubCorruptedImageAttachmentsDown,
   },
+  {
+    key: "migration_conversation_host_access_v1",
+    version: 41,
+    description:
+      "Add a host_access column to conversations so computer access is persisted per conversation with a safe default of disabled",
+    down: downConversationHostAccess,
+  },
+  {
+    key: "migration_normalize_user_file_by_principal_v1",
+    version: 42,
+    description:
+      "Normalize contacts.user_file across rows sharing the same principal_id so every channel for one principal loads the same users/<slug>.md persona and journal directory",
+    down: downNormalizeUserFileByPrincipal,
+  },
 ];
 
 export function getMaxMigrationVersion(): number {

package/src/memory/qdrant-manager.ts

@@ -269,23 +269,50 @@ export class QdrantManager {
 
   private async waitForReady(): Promise<void> {
     const start = Date.now();
+    // Build a single exited-promise once so each race reuses the same handle.
+    // Reading `proc.exitCode` synchronously inside the poll loop is unreliable
+    // in Bun: while the loop is busy with fetch() + Bun.sleep(), the
+    // subprocess-exit event may not be processed on the event loop, so
+    // `exitCode` stays null even after the process has died. Racing
+    // `proc.exited` directly forces the loop to yield and observe the exit.
+    type ExitedOutcome = { type: "exited"; code: number };
+    const exitedRace: Promise<ExitedOutcome> =
+      this.process != null
+        ? this.process.exited.then((code) => ({ type: "exited", code }))
+        : new Promise<ExitedOutcome>(() => {});
+
+    const throwOnExit = async (code: number): Promise<never> => {
+      await this.stderrDrained;
+      const stderr = this.stderrBuffer.trim();
+      throw new Error(
+        `Qdrant process exited with code ${code} before becoming ready` +
+          (stderr ? `\nstderr:\n${stderr}` : ""),
+      );
+    };
+
     while (Date.now() - start < this.readyzTimeoutMs) {
-      // Fail fast if the managed process exited before becoming ready
-      if (this.process != null && this.process.exitCode != null) {
-        await this.stderrDrained;
-        const stderr = this.stderrBuffer.trim();
-        throw new Error(
-          `Qdrant process exited with code ${this.process.exitCode} before becoming ready` +
-            (stderr ? `\nstderr:\n${stderr}` : ""),
-        );
-      }
-      try {
-        const res = await fetch(`${this.url}/readyz`);
-        if (res.ok) return;
-      } catch {
-        // Not ready yet
-      }
-      await Bun.sleep(this.readyzPollIntervalMs);
+      const fetchOutcome = await Promise.race([
+        exitedRace,
+        fetch(`${this.url}/readyz`).then(
+          (r) => ({ type: "fetch" as const, ok: r.ok }),
+          () => ({ type: "fetch" as const, ok: false }),
+        ),
+      ]);
+      if (fetchOutcome.type === "exited") await throwOnExit(fetchOutcome.code);
+      if (fetchOutcome.type === "fetch" && fetchOutcome.ok) return;
+
+      // Race the poll-interval sleep with process exit so we don't waste time
+      // sleeping after the subprocess has already died.
+      const sleepOutcome = await Promise.race([
+        exitedRace,
+        new Promise<{ type: "timeout" }>((resolve) =>
+          setTimeout(
+            () => resolve({ type: "timeout" }),
+            this.readyzPollIntervalMs,
+          ),
+        ),
+      ]);
+      if (sleepOutcome.type === "exited") await throwOnExit(sleepOutcome.code);
     }
     const stderr = this.stderrBuffer.trim();
     throw new Error(

package/src/memory/schema/conversations.ts

@@ -28,14 +28,17 @@ export const conversations = sqliteTable(
     originInterface: text("origin_interface"),
     forkParentConversationId: text("fork_parent_conversation_id"),
     forkParentMessageId: text("fork_parent_message_id"),
+    hostAccess: integer("host_access").notNull().default(0),
     isAutoTitle: integer("is_auto_title").notNull().default(1),
     scheduleJobId: text("schedule_job_id"),
     lastMessageAt: integer("last_message_at"),
+    archivedAt: integer("archived_at"),
   },
   (table) => [
     index("idx_conversations_updated_at").on(table.updatedAt),
     index("idx_conversations_last_message_at").on(table.lastMessageAt),
     index("idx_conversations_conversation_type").on(table.conversationType),
+    index("idx_conversations_archived_at").on(table.archivedAt),
     index("idx_conversations_fork_parent_conversation_id").on(
       table.forkParentConversationId,
     ),

package/src/memory/schema/oauth.ts

@@ -7,24 +7,34 @@ import {
 } from "drizzle-orm/sqlite-core";
 
 export const oauthProviders = sqliteTable("oauth_providers", {
-  providerKey: text("provider_key").primaryKey(),
-  authUrl: text("auth_url").notNull(),
-  tokenUrl: text("token_url").notNull(),
-  tokenEndpointAuthMethod: text("token_endpoint_auth_method"),
+  provider: text("provider_key").primaryKey(),
+  authorizeUrl: text("auth_url").notNull(),
+  tokenExchangeUrl: text("token_url").notNull(),
+  refreshUrl: text("refresh_url"),
+  tokenEndpointAuthMethod: text("token_endpoint_auth_method")
+    .notNull()
+    .default("client_secret_post"),
+  tokenExchangeBodyFormat: text("token_exchange_body_format")
+    .notNull()
+    .default("form"),
   userinfoUrl: text("userinfo_url"),
   baseUrl: text("base_url"),
   defaultScopes: text("default_scopes").notNull().default("[]"),
   scopePolicy: text("scope_policy").notNull().default("{}"),
-  extraParams: text("extra_params"),
+  scopeSeparator: text("scope_separator").notNull().default(" "),
+  authorizeParams: text("extra_params"),
   pingUrl: text("ping_url"),
   pingMethod: text("ping_method"),
   pingHeaders: text("ping_headers"),
   pingBody: text("ping_body"),
+  revokeUrl: text("revoke_url"),
+  revokeBodyTemplate: text("revoke_body_template"),
   managedServiceConfigKey: text("managed_service_config_key"),
-  displayName: text("display_name"),
+  displayLabel: text("display_name"),
   description: text("description"),
   dashboardUrl: text("dashboard_url"),
   clientIdPlaceholder: text("client_id_placeholder"),
+  logoUrl: text("logo_url"),
   requiresClientSecret: integer("requires_client_secret").notNull().default(1),
   loopbackPort: integer("loopback_port"),
   injectionTemplates: text("injection_templates"),
@@ -46,9 +56,9 @@ export const oauthApps = sqliteTable(
   "oauth_apps",
   {
     id: text("id").primaryKey(),
-    providerKey: text("provider_key")
+    provider: text("provider_key")
       .notNull()
-      .references(() => oauthProviders.providerKey),
+      .references(() => oauthProviders.provider),
     clientId: text("client_id").notNull(),
     clientSecretCredentialPath: text("client_secret_credential_path").notNull(),
     createdAt: integer("created_at").notNull(),
@@ -56,7 +66,7 @@ export const oauthApps = sqliteTable(
   },
   (table) => [
     uniqueIndex("idx_oauth_apps_provider_client").on(
-      table.providerKey,
+      table.provider,
       table.clientId,
     ),
   ],
@@ -69,7 +79,7 @@ export const oauthConnections = sqliteTable(
     oauthAppId: text("oauth_app_id")
       .notNull()
       .references(() => oauthApps.id),
-    providerKey: text("provider_key").notNull(),
+    provider: text("provider_key").notNull(),
     accountInfo: text("account_info"),
     grantedScopes: text("granted_scopes").notNull().default("[]"),
     expiresAt: integer("expires_at"),
@@ -80,7 +90,5 @@ export const oauthConnections = sqliteTable(
     createdAt: integer("created_at").notNull(),
     updatedAt: integer("updated_at").notNull(),
   },
-  (table) => [
-    index("idx_oauth_connections_provider_key").on(table.providerKey),
-  ],
+  (table) => [index("idx_oauth_connections_provider_key").on(table.provider)],
 );