@vellumai/assistant 0.7.3 → 0.8.1

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

@@ -35,8 +35,14 @@ import {
   resolveOffsiteDestinations,
 } from "../../backup/paths.js";
 import { restoreFromSnapshot, verifySnapshot } from "../../backup/restore.js";
-import { getConfig, invalidateConfigCache } from "../../config/loader.js";
-import type { BackupDestination } from "../../config/schema.js";
+import {
+  getConfig,
+  invalidateConfigCache,
+  loadRawConfig,
+  saveRawConfig,
+  setNestedValue,
+} from "../../config/loader.js";
+import type { BackupConfig, BackupDestination } from "../../config/schema.js";
 import { getMemoryCheckpoint } from "../../memory/checkpoints.js";
 import { getLogger } from "../../util/logger.js";
 import { getWorkspaceDir, getWorkspaceHooksDir } from "../../util/platform.js";
@@ -232,6 +238,252 @@ export async function handleBackupVerify({ body }: RouteHandlerArgs) {
   }
 }
 
+// ---------------------------------------------------------------------------
+// Config-mutation + status handlers
+// ---------------------------------------------------------------------------
+
+export async function handleBackupEnable({
+  body,
+}: RouteHandlerArgs): Promise<BackupConfig> {
+  const intervalHours = body?.intervalHours as number | undefined;
+  const retention = body?.retention as number | undefined;
+  const offsiteEnabled = body?.offsiteEnabled as boolean | undefined;
+
+  if (intervalHours !== undefined) {
+    if (
+      !Number.isFinite(intervalHours) ||
+      intervalHours < 1 ||
+      intervalHours > 168
+    ) {
+      throw new BadRequestError(
+        `intervalHours must be between 1 and 168, got ${intervalHours}`,
+      );
+    }
+  }
+  if (retention !== undefined) {
+    if (!Number.isFinite(retention) || retention < 1 || retention > 100) {
+      throw new BadRequestError(
+        `retention must be between 1 and 100, got ${retention}`,
+      );
+    }
+  }
+
+  const raw = loadRawConfig();
+  setNestedValue(raw, "backup.enabled", true);
+  if (intervalHours !== undefined) {
+    setNestedValue(raw, "backup.intervalHours", intervalHours);
+  }
+  if (retention !== undefined) {
+    setNestedValue(raw, "backup.retention", retention);
+  }
+  if (offsiteEnabled !== undefined) {
+    setNestedValue(raw, "backup.offsite.enabled", offsiteEnabled);
+  }
+  saveRawConfig(raw);
+  invalidateConfigCache();
+
+  return getConfig().backup;
+}
+
+export async function handleBackupDisable(): Promise<{ enabled: false }> {
+  const raw = loadRawConfig();
+  setNestedValue(raw, "backup.enabled", false);
+  saveRawConfig(raw);
+  invalidateConfigCache();
+  return { enabled: false };
+}
+
+export async function handleBackupDestinationsList(): Promise<{
+  destinations: BackupDestination[];
+}> {
+  const config = getConfig();
+  return {
+    destinations: resolveOffsiteDestinations(
+      config.backup.offsite.destinations,
+    ),
+  };
+}
+
+export async function handleBackupDestinationsAdd({
+  body,
+}: RouteHandlerArgs): Promise<{ destinations: BackupDestination[] }> {
+  const path = body?.path;
+  const encrypt = body?.encrypt;
+
+  if (typeof path !== "string" || path.length === 0) {
+    throw new BadRequestError(
+      "Request body must include a non-empty `path` field",
+    );
+  }
+  if (encrypt !== undefined && typeof encrypt !== "boolean") {
+    throw new BadRequestError("`encrypt` must be a boolean");
+  }
+
+  const current = resolveOffsiteDestinations(
+    getConfig().backup.offsite.destinations,
+  );
+  if (current.some((d) => d.path === path)) {
+    throw new BadRequestError(
+      `Destination "${path}" already exists. Run 'assistant backup destinations list' to see configured destinations.`,
+    );
+  }
+
+  const next: BackupDestination[] = [
+    ...current,
+    { path, encrypt: (encrypt as boolean | undefined) ?? true },
+  ];
+
+  const raw = loadRawConfig();
+  setNestedValue(raw, "backup.offsite.destinations", next);
+  saveRawConfig(raw);
+  invalidateConfigCache();
+
+  return { destinations: next };
+}
+
+export async function handleBackupDestinationsRemove({
+  body,
+}: RouteHandlerArgs): Promise<{ destinations: BackupDestination[] }> {
+  const path = body?.path;
+
+  if (typeof path !== "string" || path.length === 0) {
+    throw new BadRequestError(
+      "Request body must include a non-empty `path` field",
+    );
+  }
+
+  const current = resolveOffsiteDestinations(
+    getConfig().backup.offsite.destinations,
+  );
+  const filtered = current.filter((d) => d.path !== path);
+  if (filtered.length === current.length) {
+    throw new BadRequestError(
+      `Destination "${path}" not found. Run 'assistant backup destinations list' to see configured destinations.`,
+    );
+  }
+
+  const raw = loadRawConfig();
+  setNestedValue(raw, "backup.offsite.destinations", filtered);
+  saveRawConfig(raw);
+  invalidateConfigCache();
+
+  return { destinations: filtered };
+}
+
+export async function handleBackupDestinationsSetEncrypt({
+  body,
+}: RouteHandlerArgs): Promise<{ destination: BackupDestination }> {
+  const path = body?.path;
+  const encrypt = body?.encrypt;
+
+  if (typeof path !== "string" || path.length === 0) {
+    throw new BadRequestError(
+      "Request body must include a non-empty `path` field",
+    );
+  }
+  if (typeof encrypt !== "boolean") {
+    throw new BadRequestError("`encrypt` must be a boolean");
+  }
+
+  const current = resolveOffsiteDestinations(
+    getConfig().backup.offsite.destinations,
+  );
+  const idx = current.findIndex((d) => d.path === path);
+  if (idx === -1) {
+    throw new BadRequestError(
+      `Destination "${path}" not found. Run 'assistant backup destinations list' to see configured destinations.`,
+    );
+  }
+
+  const updated = { ...current[idx]!, encrypt };
+  const next = current.map((d, i) => (i === idx ? updated : d));
+
+  const raw = loadRawConfig();
+  setNestedValue(raw, "backup.offsite.destinations", next);
+  saveRawConfig(raw);
+  invalidateConfigCache();
+
+  return { destination: updated };
+}
+
+export async function handleBackupStatus(): Promise<{
+  enabled: boolean;
+  intervalHours: number;
+  retention: number;
+  lastRunAt: string | null;
+  nextRunAt: string | null;
+  localDir: string;
+  localSnapshotCount: number;
+  offsiteEnabled: boolean;
+  offsite: Array<{
+    path: string;
+    encrypt: boolean;
+    reachable: boolean;
+    snapshotCount: number;
+  }>;
+}> {
+  const config = getConfig();
+  const backup = config.backup;
+
+  const lastRunRaw = getMemoryCheckpoint(LAST_RUN_CHECKPOINT_KEY);
+  const lastRunMs = lastRunRaw ? Number.parseInt(lastRunRaw, 10) : NaN;
+  const lastRunAt = !Number.isNaN(lastRunMs)
+    ? new Date(lastRunMs).toISOString()
+    : null;
+
+  let nextRunAt: string | null = null;
+  if (backup.enabled && !Number.isNaN(lastRunMs)) {
+    const intervalMs = backup.intervalHours * 3600 * 1000;
+    nextRunAt = new Date(lastRunMs + intervalMs).toISOString();
+  }
+
+  const localDir = getLocalBackupsDir(backup.localDirectory);
+  const localSnapshots = await listSnapshotsInDir(localDir);
+  const localSnapshotCount = localSnapshots.length;
+
+  const offsiteEnabled = backup.offsite.enabled;
+  const offsite: Array<{
+    path: string;
+    encrypt: boolean;
+    reachable: boolean;
+    snapshotCount: number;
+  }> = [];
+
+  if (offsiteEnabled) {
+    const destinations = resolveOffsiteDestinations(
+      backup.offsite.destinations,
+    );
+    for (const dest of destinations) {
+      let reachable = false;
+      try {
+        await fs.stat(dirname(dest.path));
+        reachable = true;
+      } catch {
+        reachable = false;
+      }
+      const snapshots = reachable ? await listSnapshotsInDir(dest.path) : [];
+      offsite.push({
+        path: dest.path,
+        encrypt: dest.encrypt,
+        reachable,
+        snapshotCount: snapshots.length,
+      });
+    }
+  }
+
+  return {
+    enabled: backup.enabled,
+    intervalHours: backup.intervalHours,
+    retention: backup.retention,
+    lastRunAt,
+    nextRunAt,
+    localDir,
+    localSnapshotCount,
+    offsiteEnabled,
+    offsite,
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Route definitions
 // ---------------------------------------------------------------------------
@@ -311,4 +563,156 @@ export const ROUTES: RouteDefinition[] = [
       error: z.string().optional(),
     }),
   },
+  {
+    operationId: "backup_enable",
+    endpoint: "backup/enable",
+    method: "POST",
+    handler: handleBackupEnable,
+    summary: "Enable automated backups",
+    description:
+      "Sets backup.enabled = true. Optionally overrides intervalHours (1-168), retention (1-100), and offsiteEnabled.",
+    tags: ["backups"],
+    requestBody: z.object({
+      intervalHours: z.number().int().min(1).max(168).optional(),
+      retention: z.number().int().min(1).max(100).optional(),
+      offsiteEnabled: z.boolean().optional(),
+    }),
+    responseBody: z.object({}).passthrough(),
+  },
+  {
+    operationId: "backup_disable",
+    endpoint: "backup/disable",
+    method: "POST",
+    handler: handleBackupDisable,
+    summary: "Disable automated backups",
+    description:
+      "Sets backup.enabled = false. Existing snapshots are untouched.",
+    tags: ["backups"],
+    responseBody: z.object({
+      enabled: z.literal(false),
+    }),
+  },
+  {
+    operationId: "backup_destinations_list",
+    endpoint: "backup/destinations",
+    method: "GET",
+    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.",
+    tags: ["backups"],
+    responseBody: z.object({
+      destinations: z.array(
+        z.object({
+          path: z.string(),
+          encrypt: z.boolean(),
+        }),
+      ),
+    }),
+  },
+  {
+    operationId: "backup_destinations_add",
+    endpoint: "backup/destinations/add",
+    method: "POST",
+    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.",
+    tags: ["backups"],
+    requestBody: z.object({
+      path: z
+        .string()
+        .min(1)
+        .describe("Absolute path to the destination directory"),
+      encrypt: z
+        .boolean()
+        .optional()
+        .describe("Encrypt snapshots at this destination (default true)"),
+    }),
+    responseBody: z.object({
+      destinations: z.array(
+        z.object({
+          path: z.string(),
+          encrypt: z.boolean(),
+        }),
+      ),
+    }),
+  },
+  {
+    operationId: "backup_destinations_remove",
+    endpoint: "backup/destinations/remove",
+    method: "POST",
+    handler: handleBackupDestinationsRemove,
+    summary: "Remove an offsite backup destination",
+    description:
+      "Removes the destination matching the given path. Errors if no matching destination exists.",
+    tags: ["backups"],
+    requestBody: z.object({
+      path: z
+        .string()
+        .min(1)
+        .describe("Exact path match of the destination to remove"),
+    }),
+    responseBody: z.object({
+      destinations: z.array(
+        z.object({
+          path: z.string(),
+          encrypt: z.boolean(),
+        }),
+      ),
+    }),
+  },
+  {
+    operationId: "backup_destinations_set_encrypt",
+    endpoint: "backup/destinations/set-encrypt",
+    method: "POST",
+    handler: handleBackupDestinationsSetEncrypt,
+    summary: "Toggle encryption for an existing destination",
+    description:
+      "Updates the encrypt flag for a destination. Errors if no destination with the given path exists.",
+    tags: ["backups"],
+    requestBody: z.object({
+      path: z
+        .string()
+        .min(1)
+        .describe("Exact path match of an existing destination"),
+      encrypt: z
+        .boolean()
+        .describe("true to encrypt future snapshots, false for plaintext"),
+    }),
+    responseBody: z.object({
+      destination: z.object({
+        path: z.string(),
+        encrypt: z.boolean(),
+      }),
+    }),
+  },
+  {
+    operationId: "backup_status",
+    endpoint: "backup/status",
+    method: "GET",
+    handler: handleBackupStatus,
+    summary: "Show backup status and next-run timing",
+    description:
+      "Reports enabled/disabled state, interval and retention, last-run and next-run timing from the backup:last_run_at checkpoint, local snapshot count, and per-destination reachability and snapshot counts. When `backup.offsite.enabled` is false the `offsite` array is empty and `offsiteEnabled` is false.",
+    tags: ["backups"],
+    responseBody: z.object({
+      enabled: z.boolean(),
+      intervalHours: z.number(),
+      retention: z.number(),
+      lastRunAt: z.string().nullable(),
+      nextRunAt: z.string().nullable(),
+      localDir: z.string(),
+      localSnapshotCount: z.number(),
+      offsiteEnabled: z.boolean(),
+      offsite: z.array(
+        z.object({
+          path: z.string(),
+          encrypt: z.boolean(),
+          reachable: z.boolean(),
+          snapshotCount: z.number(),
+        }),
+      ),
+    }),
+  },
 ];

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

@@ -0,0 +1,154 @@
+/**
+ * Route handlers for message bookmarks.
+ *
+ * GET    /v1/bookmarks                      — list all bookmarks (newest first)
+ * POST   /v1/bookmarks                      — bookmark a message (idempotent)
+ * DELETE /v1/bookmarks/by-message/:messageId — remove the bookmark for a given message
+ *
+ * Mutating routes publish `bookmark.created` / `bookmark.deleted` events
+ * via `assistantEventHub` so any other connected client (e.g. a second
+ * macOS window) can refresh its `BookmarkStore` in lock-step.
+ */
+
+import { z } from "zod";
+
+import {
+  type BookmarkSummary,
+  createBookmark,
+  deleteBookmarkByMessageId,
+  listBookmarks,
+} from "../../memory/bookmark-crud.js";
+import { getMessageById } from "../../memory/conversation-crud.js";
+import { getDb } from "../../memory/db-connection.js";
+import { getLogger } from "../../util/logger.js";
+import { buildAssistantEvent } from "../assistant-event.js";
+import { assistantEventHub } from "../assistant-event-hub.js";
+import { BadRequestError, NotFoundError } from "./errors.js";
+import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
+
+const log = getLogger("bookmark-routes");
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function publishBookmarkCreated(bookmark: BookmarkSummary): void {
+  assistantEventHub
+    .publish(buildAssistantEvent({ type: "bookmark.created", bookmark }))
+    .catch((err) => {
+      log.warn({ err }, "Failed to publish bookmark.created");
+    });
+}
+
+function publishBookmarkDeleted(payload: { messageId: string }): void {
+  assistantEventHub
+    .publish(buildAssistantEvent({ type: "bookmark.deleted", ...payload }))
+    .catch((err) => {
+      log.warn({ err }, "Failed to publish bookmark.deleted");
+    });
+}
+
+// ---------------------------------------------------------------------------
+// Handlers
+// ---------------------------------------------------------------------------
+
+function handleListBookmarks(): { bookmarks: BookmarkSummary[] } {
+  return { bookmarks: listBookmarks(getDb()) };
+}
+
+function handleCreateBookmark({
+  body = {},
+}: RouteHandlerArgs): BookmarkSummary {
+  const messageId = body.messageId as string | undefined;
+  const conversationId = body.conversationId as string | undefined;
+
+  if (!messageId || typeof messageId !== "string") {
+    throw new BadRequestError("messageId is required");
+  }
+  if (!conversationId || typeof conversationId !== "string") {
+    throw new BadRequestError("conversationId is required");
+  }
+
+  // Validate the message belongs to the named conversation up-front. The FK
+  // constraints would also reject a bad insert, but explicit validation
+  // keeps the idempotent path from returning a previously-bookmarked row
+  // that happens to live under a different conversation id.
+  if (!getMessageById(messageId, conversationId)) {
+    throw new NotFoundError(
+      `Message ${messageId} not found in conversation ${conversationId}`,
+    );
+  }
+
+  const summary = createBookmark(getDb(), { messageId, conversationId });
+  publishBookmarkCreated(summary);
+  return summary;
+}
+
+function handleDeleteBookmarkByMessage({ pathParams = {} }: RouteHandlerArgs): {
+  success: true;
+} {
+  const messageId = pathParams.messageId;
+  if (!messageId) {
+    throw new BadRequestError("messageId is required");
+  }
+  const removed = deleteBookmarkByMessageId(getDb(), messageId);
+  if (removed) {
+    publishBookmarkDeleted({ messageId });
+  }
+  return { success: true };
+}
+
+// ---------------------------------------------------------------------------
+// Route definitions
+// ---------------------------------------------------------------------------
+
+const bookmarkSummarySchema = z.object({
+  id: z.string(),
+  messageId: z.string(),
+  conversationId: z.string(),
+  conversationTitle: z.string().nullable(),
+  messagePreview: z.string(),
+  messageRole: z.string(),
+  messageCreatedAt: z.number(),
+  createdAt: z.number(),
+});
+
+export const ROUTES: RouteDefinition[] = [
+  {
+    operationId: "bookmarks_list",
+    endpoint: "bookmarks",
+    method: "GET",
+    summary: "List bookmarks",
+    description:
+      "Return all bookmarks (newest first), joined with their parent message and conversation.",
+    tags: ["bookmarks"],
+    responseBody: z.object({ bookmarks: z.array(bookmarkSummarySchema) }),
+    handler: handleListBookmarks,
+  },
+  {
+    operationId: "bookmarks_create",
+    endpoint: "bookmarks",
+    method: "POST",
+    summary: "Create a bookmark",
+    description:
+      "Bookmark the given message. Idempotent on `messageId` — calling twice returns the same bookmark.",
+    tags: ["bookmarks"],
+    requestBody: z.object({
+      messageId: z.string(),
+      conversationId: z.string(),
+    }),
+    responseBody: bookmarkSummarySchema,
+    handler: handleCreateBookmark,
+  },
+  {
+    operationId: "bookmarks_delete_by_message",
+    endpoint: "bookmarks/by-message/:messageId",
+    method: "DELETE",
+    summary: "Delete a bookmark by message id",
+    description:
+      "Delete the bookmark (if any) attached to the given message. Succeeds even if no row matched.",
+    tags: ["bookmarks"],
+    responseBody: z.object({ success: z.literal(true) }),
+    handler: handleDeleteBookmarkByMessage,
+  },
+];

package/src/runtime/routes/channel-verification-routes.ts

@@ -177,8 +177,9 @@ export async function handleCreateVerificationSession({
  */
 function handleGetVerificationStatus({
   queryParams = {},
+  body = {},
 }: RouteHandlerArgs) {
-  const channel = (queryParams.channel as ChannelId | undefined) ?? undefined;
+  const channel = (queryParams.channel ?? (body as Record<string, unknown>).channel) as ChannelId | undefined;
   return getVerificationStatus(channel);
 }
 

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

@@ -8,13 +8,13 @@
  * only surface its config and provide an on-demand trigger for the Settings UI.
  *
  * `available` mirrors the filing route's `available` field: it reflects which
- * background memory job is active for this instance. When `memory-v2-enabled`
- * is off, consolidation returns `available: false` and the UI hides the row.
+ * background memory job is active for this instance. When
+ * `config.memory.v2.enabled` is false, consolidation returns
+ * `available: false` and the UI hides the row.
  */
 
 import { z } from "zod";
 
-import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
 import { getConfig } from "../../config/loader.js";
 import { getMemoryCheckpoint } from "../../memory/checkpoints.js";
 import {
@@ -26,7 +26,7 @@ import { BadRequestError } from "./errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
 function isConsolidationAvailable(): boolean {
-  return isAssistantFeatureFlagEnabled("memory-v2-enabled", getConfig());
+  return getConfig().memory.v2.enabled;
 }
 
 function consolidationIntervalMs(): number {
@@ -66,14 +66,13 @@ export const ROUTES: RouteDefinition[] = [
       success: z.boolean(),
     }),
     handler: async (_args: RouteHandlerArgs) => {
-      const available = isConsolidationAvailable();
-      const v2Config = getConfig().memory.v2;
+      const enabled = getConfig().memory.v2.enabled;
       const intervalMs = consolidationIntervalMs();
       const lastRunAt = readLastRunAt();
       const nextRunAt = lastRunAt != null ? lastRunAt + intervalMs : null;
       return {
-        available,
-        enabled: available && v2Config.enabled,
+        available: enabled,
+        enabled,
         intervalMs,
         nextRunAt,
         lastRunAt,
@@ -99,7 +98,7 @@ export const ROUTES: RouteDefinition[] = [
     handler: async (_args: RouteHandlerArgs) => {
       if (!isConsolidationAvailable()) {
         throw new BadRequestError(
-          "Consolidation is not available (memory-v2-enabled is off)",
+          "Consolidation is not available (memory.v2.enabled is false)",
         );
       }
       // Coalesce: don't pile up duplicate jobs if the worker hasn't picked up