@vellumai/assistant 0.5.5 → 0.5.7

package/src/runtime/routes/migration-rollback-routes.ts

@@ -0,0 +1,209 @@
+/**
+ * Migration rollback endpoint — rolls back DB and/or workspace migrations
+ * to a specified target version/migration ID.
+ *
+ * Protected by a route policy restricting access to gateway service
+ * principals only (`svc_gateway` with `internal.write` scope), following
+ * the same pattern as other gateway-forwarded control-plane endpoints.
+ */
+
+import { getDb } from "../../memory/db-connection.js";
+import { getMaxMigrationVersion } from "../../memory/migrations/registry.js";
+import { rollbackMemoryMigration } from "../../memory/migrations/validate-migration-state.js";
+import { getWorkspaceDir } from "../../util/platform.js";
+import { WORKSPACE_MIGRATIONS } from "../../workspace/migrations/registry.js";
+import {
+  getLastWorkspaceMigrationId,
+  loadCheckpoints,
+  rollbackWorkspaceMigrations,
+} from "../../workspace/migrations/runner.js";
+import { httpError } from "../http-errors.js";
+import type { RouteDefinition } from "../http-router.js";
+
+export function migrationRollbackRouteDefinitions(): RouteDefinition[] {
+  return [
+    {
+      endpoint: "admin/rollback-migrations",
+      method: "POST",
+      handler: async ({ req }) => {
+        let body: unknown;
+        try {
+          body = await req.json();
+        } catch {
+          return httpError("BAD_REQUEST", "Invalid JSON body", 400);
+        }
+
+        if (!body || typeof body !== "object") {
+          return httpError(
+            "BAD_REQUEST",
+            "Request body must be a JSON object",
+            400,
+          );
+        }
+
+        const {
+          targetDbVersion,
+          targetWorkspaceMigrationId,
+          rollbackToRegistryCeiling,
+        } = body as {
+          targetDbVersion?: unknown;
+          targetWorkspaceMigrationId?: unknown;
+          rollbackToRegistryCeiling?: unknown;
+        };
+
+        // When rollbackToRegistryCeiling is true, auto-determine targets
+        // from this daemon's own migration registry ceilings.
+        let effectiveDbVersion = targetDbVersion as number | undefined;
+        let effectiveWorkspaceMigrationId = targetWorkspaceMigrationId as
+          | string
+          | undefined;
+
+        if (rollbackToRegistryCeiling === true) {
+          if (effectiveDbVersion === undefined)
+            effectiveDbVersion = getMaxMigrationVersion();
+          if (effectiveWorkspaceMigrationId === undefined)
+            effectiveWorkspaceMigrationId =
+              getLastWorkspaceMigrationId(WORKSPACE_MIGRATIONS) ?? undefined;
+        }
+
+        // At least one rollback target must be specified.
+        if (
+          effectiveDbVersion === undefined &&
+          effectiveWorkspaceMigrationId === undefined
+        ) {
+          return httpError(
+            "BAD_REQUEST",
+            "At least one of targetDbVersion or targetWorkspaceMigrationId must be provided",
+            400,
+          );
+        }
+
+        // Validate effectiveDbVersion when provided.
+        if (effectiveDbVersion !== undefined) {
+          if (
+            typeof effectiveDbVersion !== "number" ||
+            !Number.isInteger(effectiveDbVersion) ||
+            effectiveDbVersion < 0
+          ) {
+            return httpError(
+              "BAD_REQUEST",
+              "targetDbVersion must be a non-negative integer",
+              400,
+            );
+          }
+        }
+
+        // Validate effectiveWorkspaceMigrationId when provided.
+        if (effectiveWorkspaceMigrationId !== undefined) {
+          if (
+            typeof effectiveWorkspaceMigrationId !== "string" ||
+            effectiveWorkspaceMigrationId.length === 0
+          ) {
+            return httpError(
+              "BAD_REQUEST",
+              "targetWorkspaceMigrationId must be a non-empty string",
+              400,
+            );
+          }
+        }
+
+        // Preflight: validate that the workspace migration ID exists in the
+        // registry BEFORE executing any mutations. This prevents the DB
+        // rollback from committing when the workspace target is invalid.
+        let resolvedTargetIndex = -1;
+        if (effectiveWorkspaceMigrationId !== undefined) {
+          const targetId = effectiveWorkspaceMigrationId as string;
+          resolvedTargetIndex = WORKSPACE_MIGRATIONS.findIndex(
+            (m) => m.id === targetId,
+          );
+          if (resolvedTargetIndex === -1) {
+            return httpError(
+              "BAD_REQUEST",
+              `Target workspace migration "${targetId}" not found in the registry`,
+              400,
+            );
+          }
+        }
+
+        const rolledBack: { db: string[]; workspace: string[] } = {
+          db: [],
+          workspace: [],
+        };
+
+        // Roll back DB migrations if requested.
+        if (effectiveDbVersion !== undefined) {
+          try {
+            rolledBack.db = rollbackMemoryMigration(
+              getDb(),
+              effectiveDbVersion,
+            );
+          } catch (err) {
+            const detail = err instanceof Error ? err.message : "Unknown error";
+            return httpError(
+              "INTERNAL_ERROR",
+              `DB migration rollback failed: ${detail}`,
+              500,
+            );
+          }
+        }
+
+        // Roll back workspace migrations if requested.
+        if (effectiveWorkspaceMigrationId !== undefined) {
+          const workspaceDir = getWorkspaceDir();
+
+          // Compute which migrations are candidates for rollback before
+          // executing, since rollbackWorkspaceMigrations returns void.
+          const targetId = effectiveWorkspaceMigrationId;
+
+          const checkpointsBefore = loadCheckpoints(workspaceDir);
+          const candidateIds = WORKSPACE_MIGRATIONS.slice(
+            resolvedTargetIndex + 1,
+          )
+            .filter((m) => {
+              const entry = checkpointsBefore.applied[m.id];
+              return (
+                entry &&
+                entry.status !== "started" &&
+                entry.status !== "rolling_back"
+              );
+            })
+            .map((m) => m.id);
+
+          try {
+            await rollbackWorkspaceMigrations(
+              workspaceDir,
+              WORKSPACE_MIGRATIONS,
+              targetId,
+            );
+
+            rolledBack.workspace = candidateIds;
+          } catch (err) {
+            // Re-read checkpoints to determine which migrations were actually
+            // rolled back before the error occurred. A candidate whose entry
+            // is no longer present in the checkpoint file was successfully
+            // reverted.
+            const checkpointsAfter = loadCheckpoints(workspaceDir);
+            const actuallyRolledBack = candidateIds.filter(
+              (id) => !checkpointsAfter.applied[id],
+            );
+
+            const detail = err instanceof Error ? err.message : "Unknown error";
+            return httpError(
+              "INTERNAL_ERROR",
+              `Workspace migration rollback failed: ${detail}`,
+              500,
+              {
+                partialRolledBack: {
+                  db: rolledBack.db,
+                  workspace: actuallyRolledBack,
+                },
+              },
+            );
+          }
+        }
+
+        return Response.json({ ok: true, rolledBack });
+      },
+    },
+  ];
+}

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

@@ -15,7 +15,8 @@ import { join } from "node:path";
 import { Database } from "bun:sqlite";
 
 import { invalidateConfigCache } from "../../config/loader.js";
-import { resetDb } from "../../memory/db-connection.js";
+import { getDb, resetDb } from "../../memory/db-connection.js";
+import { validateMigrationState } from "../../memory/migrations/validate-migration-state.js";
 import { clearCache as clearTrustCache } from "../../permissions/trust-store.js";
 import { getLogger } from "../../util/logger.js";
 import {
@@ -438,6 +439,21 @@ export async function handleMigrationImport(req: Request): Promise<Response> {
     invalidateConfigCache();
     clearTrustCache();
 
+    // Check whether the imported database contains migration checkpoints from
+    // a newer version. This is non-blocking — the import has already
+    // succeeded — but we surface a warning so the caller knows some data may
+    // not be fully compatible with this daemon's schema.
+    try {
+      const migrationValidation = validateMigrationState(getDb());
+      if (migrationValidation.unknownCheckpoints.length > 0) {
+        result.report.warnings.push(
+          `Imported data contains ${migrationValidation.unknownCheckpoints.length} migration(s) from a newer version. Some data may not be fully compatible.`,
+        );
+      }
+    } catch {
+      // Don't fail the import if validation itself errors
+    }
+
     return Response.json(result.report);
   } catch (err) {
     log.error({ err }, "Unexpected error during import commit");

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

@@ -0,0 +1,58 @@
+/**
+ * Route handlers for notification delivery acknowledgments.
+ *
+ * Provides a REST endpoint for clients to report the outcome of
+ * local notification delivery (UNUserNotificationCenter.add).
+ */
+
+import { eq } from "drizzle-orm";
+
+import { getDb } from "../../memory/db.js";
+import { notificationDeliveries } from "../../memory/schema.js";
+import { httpError } from "../http-errors.js";
+import type { RouteDefinition } from "../http-router.js";
+
+export function notificationRouteDefinitions(): RouteDefinition[] {
+  return [
+    // POST /v1/notification-intent-result — client ack for notification delivery
+    {
+      endpoint: "notification-intent-result",
+      method: "POST",
+      policyKey: "notification-intent-result",
+      handler: async ({ req }) => {
+        const body = (await req.json()) as {
+          deliveryId?: string;
+          success?: boolean;
+          errorMessage?: string;
+          errorCode?: string;
+        };
+
+        if (!body.deliveryId || typeof body.deliveryId !== "string") {
+          return httpError("BAD_REQUEST", "deliveryId is required", 400);
+        }
+
+        const db = getDb();
+        const now = Date.now();
+
+        const updates: Record<string, unknown> = {
+          clientDeliveryStatus: body.success ? "delivered" : "client_failed",
+          clientDeliveryAt: now,
+          updatedAt: now,
+        };
+        if (body.errorMessage) {
+          updates.clientDeliveryError = body.errorMessage;
+        }
+        if (body.errorCode) {
+          updates.errorCode = body.errorCode;
+        }
+
+        db.update(notificationDeliveries)
+          .set(updates)
+          .where(eq(notificationDeliveries.id, body.deliveryId))
+          .run();
+
+        return Response.json({ ok: true });
+      },
+    },
+  ];
+}

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

@@ -99,6 +99,59 @@ function handleCancelSchedule(id: string): Response {
   return handleListSchedules();
 }
 
+const VALID_MODES = ["notify", "execute"] as const;
+const VALID_ROUTING_INTENTS = [
+  "single_channel",
+  "multi_channel",
+  "all_channels",
+] as const;
+
+function handleUpdateSchedule(
+  id: string,
+  body: Record<string, unknown>,
+): Response {
+  const updates: Record<string, unknown> = {};
+
+  if ("mode" in body && !VALID_MODES.includes(body.mode as (typeof VALID_MODES)[number])) {
+    return httpError("BAD_REQUEST", `Invalid mode: must be one of ${VALID_MODES.join(", ")}`, 400);
+  }
+  if ("routingIntent" in body && !VALID_ROUTING_INTENTS.includes(body.routingIntent as (typeof VALID_ROUTING_INTENTS)[number])) {
+    return httpError("BAD_REQUEST", `Invalid routingIntent: must be one of ${VALID_ROUTING_INTENTS.join(", ")}`, 400);
+  }
+
+  for (const key of [
+    "name",
+    "expression",
+    "timezone",
+    "message",
+    "mode",
+    "routingIntent",
+    "quiet",
+  ] as const) {
+    if (key in body) {
+      updates[key] = body[key];
+    }
+  }
+
+  try {
+    const updated = updateSchedule(id, updates);
+    if (!updated) {
+      return httpError("NOT_FOUND", "Schedule not found", 404);
+    }
+    log.info({ id, updates }, "Schedule updated via HTTP");
+  } catch (err) {
+    if (
+      err instanceof Error &&
+      (err.message.includes("Invalid") || err.message.includes("invalid"))
+    ) {
+      return httpError("BAD_REQUEST", err.message, 400);
+    }
+    log.error({ err }, "Failed to update schedule");
+    return httpError("INTERNAL_ERROR", "Failed to update schedule", 500);
+  }
+  return handleListSchedules();
+}
+
 async function handleRunScheduleNow(
   id: string,
   sendMessageDeps?: SendMessageDeps,
@@ -243,6 +296,18 @@ export function scheduleRouteDefinitions(deps: {
       policyKey: "schedules",
       handler: ({ params }) => handleDeleteSchedule(params.id),
     },
+    {
+      endpoint: "schedules/:id",
+      method: "PATCH",
+      policyKey: "schedules",
+      handler: async ({ req, params }) => {
+        const body: unknown = await req.json();
+        if (typeof body !== "object" || !body || Array.isArray(body)) {
+          return httpError("BAD_REQUEST", "Request body must be a JSON object", 400);
+        }
+        return handleUpdateSchedule(params.id, body as Record<string, unknown>);
+      },
+    },
     {
       endpoint: "schedules/:id/run",
       method: "POST",

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

@@ -10,7 +10,10 @@
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 
-import { setIngressPublicBaseUrl } from "../../config/env.js";
+import {
+  getPlatformBaseUrl,
+  setIngressPublicBaseUrl,
+} from "../../config/env.js";
 import { loadRawConfig, saveRawConfig } from "../../config/loader.js";
 import { loadSkillCatalog } from "../../config/skills.js";
 import {
@@ -728,6 +731,43 @@ export function settingsRouteDefinitions(): RouteDefinition[] {
       handler: () => handleEnvVars(),
     },
 
+    // Platform config (GET / PUT)
+    {
+      endpoint: "config/platform",
+      method: "GET",
+      policyKey: "config/platform:GET",
+      handler: () => {
+        const raw = loadRawConfig();
+        const platform = (raw?.platform ?? {}) as Record<string, unknown>;
+        const baseUrl =
+          (platform.baseUrl as string | undefined) || getPlatformBaseUrl();
+        return Response.json({ baseUrl, success: true });
+      },
+    },
+    {
+      endpoint: "config/platform",
+      method: "PUT",
+      policyKey: "config/platform",
+      handler: async ({ req }) => {
+        try {
+          const body = (await req.json()) as { baseUrl?: string };
+          const value = (body.baseUrl ?? "").trim().replace(/\/+$/, "");
+          const raw = loadRawConfig();
+          const platform = (raw?.platform ?? {}) as Record<string, unknown>;
+          platform.baseUrl = value || undefined;
+          saveRawConfig({ ...raw, platform });
+          return Response.json({ baseUrl: value, success: true });
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          log.error({ err }, "Failed to update platform config via HTTP");
+          return Response.json(
+            { baseUrl: "", success: false, error: message },
+            { status: 500 },
+          );
+        }
+      },
+    },
+
     // Ingress config (GET / PUT)
     {
       endpoint: "integrations/ingress/config",

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

@@ -0,0 +1,86 @@
+/**
+ * HTTP route definitions for message text-to-speech synthesis.
+ *
+ * POST /v1/messages/:id/tts?conversationId=... — synthesize message text to audio
+ *
+ * Gated behind the `feature_flags.message-tts.enabled` assistant feature flag.
+ * Uses Fish Audio for synthesis when configured.
+ */
+
+import { synthesizeWithFishAudio } from "../../calls/fish-audio-client.js";
+import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
+import { getConfig } from "../../config/loader.js";
+import { getMessageContent } from "../../daemon/handlers/conversation-history.js";
+import { getLogger } from "../../util/logger.js";
+import { httpError } from "../http-errors.js";
+import type { RouteDefinition } from "../http-router.js";
+
+const log = getLogger("tts-routes");
+
+const MESSAGE_TTS_FLAG = "feature_flags.message-tts.enabled" as const;
+
+// ---------------------------------------------------------------------------
+// Route definitions
+// ---------------------------------------------------------------------------
+
+export function ttsRouteDefinitions(): RouteDefinition[] {
+  return [
+    {
+      endpoint: "messages/:id/tts",
+      method: "POST",
+      policyKey: "messages/tts",
+      handler: async ({ url, params }) => {
+        const config = getConfig();
+
+        if (!isAssistantFeatureFlagEnabled(MESSAGE_TTS_FLAG, config)) {
+          return httpError("FORBIDDEN", "Message TTS is not enabled", 403);
+        }
+
+        const messageId = params.id;
+        const conversationId =
+          url.searchParams.get("conversationId") ?? undefined;
+
+        const result = getMessageContent(messageId, conversationId);
+        if (!result) {
+          return httpError("NOT_FOUND", `Message ${messageId} not found`, 404);
+        }
+
+        if (!result.text) {
+          return httpError("BAD_REQUEST", "Message has no text content", 400);
+        }
+
+        const { fishAudio } = config;
+        if (!fishAudio?.referenceId) {
+          return httpError(
+            "SERVICE_UNAVAILABLE",
+            "Fish Audio TTS is not configured",
+            503,
+          );
+        }
+
+        try {
+          const audioBuffer = await synthesizeWithFishAudio(
+            result.text,
+            fishAudio,
+          );
+
+          const format = fishAudio.format ?? "mp3";
+          const contentType =
+            format === "wav"
+              ? "audio/wav"
+              : format === "opus"
+                ? "audio/opus"
+                : "audio/mpeg";
+
+          return new Response(new Uint8Array(audioBuffer), {
+            status: 200,
+            headers: { "Content-Type": contentType },
+          });
+        } catch (err) {
+          log.error({ err, messageId }, "TTS synthesis failed");
+          return httpError("INTERNAL_ERROR", "TTS synthesis failed", 502);
+        }
+      },
+    },
+  ];
+}

package/src/runtime/routes/upgrade-broadcast-routes.ts

@@ -0,0 +1,175 @@
+/**
+ * Upgrade broadcast endpoint — publishes service group update lifecycle
+ * events (starting / progress / complete) to all connected SSE clients.
+ *
+ * Protected by a route policy restricting access to gateway service
+ * principals only (`svc_gateway` with `internal.write` scope), following
+ * the same pattern as other gateway-forwarded control-plane endpoints.
+ * The gateway requires a valid edge JWT and forwards the request with a
+ * minted service token.
+ */
+
+import type {
+  ServiceGroupUpdateComplete,
+  ServiceGroupUpdateProgress,
+  ServiceGroupUpdateStarting,
+} from "../../daemon/message-types/upgrades.js";
+import { buildAssistantEvent } from "../assistant-event.js";
+import { assistantEventHub } from "../assistant-event-hub.js";
+import { DAEMON_INTERNAL_ASSISTANT_ID } from "../assistant-scope.js";
+import { httpError } from "../http-errors.js";
+import type { RouteDefinition } from "../http-router.js";
+
+export function upgradeBroadcastRouteDefinitions(): RouteDefinition[] {
+  return [
+    {
+      endpoint: "admin/upgrade-broadcast",
+      method: "POST",
+      handler: async ({ req }) => {
+        let body: unknown;
+        try {
+          body = await req.json();
+        } catch {
+          return httpError("BAD_REQUEST", "Invalid JSON body", 400);
+        }
+
+        if (!body || typeof body !== "object") {
+          return httpError(
+            "BAD_REQUEST",
+            "Request body must be a JSON object",
+            400,
+          );
+        }
+
+        const { type } = body as { type?: unknown };
+
+        if (type === "starting") {
+          const { targetVersion, expectedDowntimeSeconds } = body as {
+            targetVersion?: unknown;
+            expectedDowntimeSeconds?: unknown;
+          };
+
+          if (typeof targetVersion !== "string" || targetVersion.length === 0) {
+            return httpError(
+              "BAD_REQUEST",
+              "targetVersion is required and must be a non-empty string",
+              400,
+            );
+          }
+
+          const downtime =
+            expectedDowntimeSeconds === undefined
+              ? 60
+              : expectedDowntimeSeconds;
+
+          if (
+            typeof downtime !== "number" ||
+            !isFinite(downtime) ||
+            downtime < 0
+          ) {
+            return httpError(
+              "BAD_REQUEST",
+              "expectedDowntimeSeconds must be a non-negative number",
+              400,
+            );
+          }
+
+          const message: ServiceGroupUpdateStarting = {
+            type: "service_group_update_starting",
+            targetVersion,
+            expectedDowntimeSeconds: downtime,
+          };
+
+          await assistantEventHub.publish(
+            buildAssistantEvent(DAEMON_INTERNAL_ASSISTANT_ID, message),
+          );
+
+          return Response.json({ ok: true });
+        }
+
+        if (type === "progress") {
+          const { statusMessage } = body as { statusMessage?: unknown };
+
+          if (typeof statusMessage !== "string" || statusMessage.length === 0) {
+            return httpError(
+              "BAD_REQUEST",
+              "statusMessage is required and must be a non-empty string",
+              400,
+            );
+          }
+
+          const message: ServiceGroupUpdateProgress = {
+            type: "service_group_update_progress",
+            statusMessage,
+          };
+
+          await assistantEventHub.publish(
+            buildAssistantEvent(DAEMON_INTERNAL_ASSISTANT_ID, message),
+          );
+
+          return Response.json({ ok: true });
+        }
+
+        if (type === "complete") {
+          const { installedVersion, success, rolledBackToVersion } = body as {
+            installedVersion?: unknown;
+            success?: unknown;
+            rolledBackToVersion?: unknown;
+          };
+
+          if (
+            typeof installedVersion !== "string" ||
+            installedVersion.length === 0
+          ) {
+            return httpError(
+              "BAD_REQUEST",
+              "installedVersion is required and must be a non-empty string",
+              400,
+            );
+          }
+
+          if (typeof success !== "boolean") {
+            return httpError(
+              "BAD_REQUEST",
+              "success is required and must be a boolean",
+              400,
+            );
+          }
+
+          if (
+            rolledBackToVersion !== undefined &&
+            (typeof rolledBackToVersion !== "string" ||
+              rolledBackToVersion.length === 0)
+          ) {
+            return httpError(
+              "BAD_REQUEST",
+              "rolledBackToVersion must be a non-empty string when provided",
+              400,
+            );
+          }
+
+          const message: ServiceGroupUpdateComplete = {
+            type: "service_group_update_complete",
+            installedVersion,
+            success,
+            ...(typeof rolledBackToVersion === "string"
+              ? { rolledBackToVersion }
+              : {}),
+          };
+
+          await assistantEventHub.publish(
+            buildAssistantEvent(DAEMON_INTERNAL_ASSISTANT_ID, message),
+          );
+
+          return Response.json({ ok: true });
+        }
+
+        return httpError(
+          "BAD_REQUEST",
+          'type must be "starting", "progress", or "complete"',
+          400,
+        );
+      },
+    },
+  ];
+}