@vellumai/assistant 0.8.12 → 0.9.0-staging.2

package/src/runtime/routes/sounds-config-routes.ts

@@ -0,0 +1,239 @@
+/**
+ * Dedicated routes for reading/writing the sounds configuration
+ * (`data/sounds/config.json`) and listing available sound files.
+ *
+ * These replace the generic workspace file endpoints for sounds,
+ * providing typed Zod schemas so the generated SDK produces typed
+ * response helpers (`soundsConfigGetSetQueryData`, etc.).
+ */
+
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+
+import { z } from "zod";
+
+import { getSoundsDir } from "../../util/platform.js";
+import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
+import { publishSoundsConfigUpdated } from "../sync/resource-sync-events.js";
+import { BadRequestError } from "./errors.js";
+import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
+
+// ---------------------------------------------------------------------------
+// Schemas
+// ---------------------------------------------------------------------------
+
+const SUPPORTED_EXTENSIONS = new Set(["aiff", "wav", "mp3", "m4a", "caf"]);
+
+const soundEventConfigSchema = z.object({
+  enabled: z.boolean(),
+  sounds: z.array(z.string()),
+});
+
+const soundsConfigSchema = z.object({
+  globalEnabled: z.boolean(),
+  volume: z.number(),
+  events: z.record(z.string(), soundEventConfigSchema),
+});
+
+const lenientSoundEventSchema = z
+  .object({
+    enabled: z.boolean().catch(false),
+    sounds: z
+      .array(z.string().catch(""))
+      .catch([])
+      .transform((arr) => arr.filter(Boolean)),
+  })
+  .catch({ enabled: false, sounds: [] });
+
+const lenientSoundsConfigSchema = z
+  .object({
+    globalEnabled: z.boolean().catch(false),
+    volume: z
+      .number()
+      .catch(0.7)
+      .transform((v) => Math.max(0, Math.min(1, v))),
+    events: z.record(z.string(), lenientSoundEventSchema).catch({}),
+  })
+  .catch({ globalEnabled: false, volume: 0.7, events: {} });
+
+const availableSoundSchema = z.object({
+  label: z.string(),
+  filename: z.string(),
+});
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+const CONFIG_FILENAME = "config.json";
+
+function configPath(): string {
+  return join(getSoundsDir(), CONFIG_FILENAME);
+}
+
+const SOUND_EVENT_IDS = [
+  "task_complete",
+  "needs_input",
+  "task_failed",
+  "notification",
+  "new_conversation",
+  "message_sent",
+  "character_poke",
+  "random",
+] as const;
+
+type SoundsConfig = z.infer<typeof soundsConfigSchema>;
+
+function defaultEvents(): Record<
+  string,
+  z.infer<typeof soundEventConfigSchema>
+> {
+  const events: Record<string, z.infer<typeof soundEventConfigSchema>> = {};
+  for (const id of SOUND_EVENT_IDS) {
+    events[id] = { enabled: false, sounds: [] };
+  }
+  return events;
+}
+
+function normalise(input: unknown): SoundsConfig {
+  const parsed = lenientSoundsConfigSchema.parse(input);
+  const mergedEvents = { ...defaultEvents(), ...parsed.events };
+  return { ...parsed, events: mergedEvents };
+}
+
+function readConfig(): SoundsConfig {
+  const path = configPath();
+  try {
+    const text = readFileSync(path, "utf-8");
+    return normalise(JSON.parse(text));
+  } catch {
+    return normalise(undefined);
+  }
+}
+
+function writeConfig(config: SoundsConfig): void {
+  const dir = getSoundsDir();
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(configPath(), JSON.stringify(config, null, 2), "utf-8");
+}
+
+function hasSupportedExtension(filename: string): boolean {
+  const idx = filename.lastIndexOf(".");
+  if (idx < 0 || idx === filename.length - 1) return false;
+  return SUPPORTED_EXTENSIONS.has(filename.slice(idx + 1).toLowerCase());
+}
+
+function displayLabel(filename: string): string {
+  const idx = filename.lastIndexOf(".");
+  if (idx <= 0) return filename;
+  return filename.slice(0, idx);
+}
+
+// ---------------------------------------------------------------------------
+// Handlers
+// ---------------------------------------------------------------------------
+
+function handleGetSoundsConfig() {
+  return readConfig();
+}
+
+function handlePutSoundsConfig({ body }: RouteHandlerArgs) {
+  if (!body) {
+    throw new BadRequestError("Request body is required");
+  }
+  const parsed = soundsConfigSchema.safeParse(body);
+  if (!parsed.success) {
+    throw new BadRequestError(`Invalid sounds config: ${parsed.error.message}`);
+  }
+  const config: SoundsConfig = {
+    ...parsed.data,
+    volume: Math.max(0, Math.min(1, parsed.data.volume)),
+    events: { ...defaultEvents(), ...parsed.data.events },
+  };
+  writeConfig(config);
+  publishSoundsConfigUpdated();
+  return config;
+}
+
+function handleListAvailableSounds() {
+  const dir = getSoundsDir();
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    const sounds: Array<{ label: string; filename: string }> = [];
+    for (const entry of entries) {
+      if (!entry.isFile()) continue;
+      const name = entry.name;
+      if (name === CONFIG_FILENAME) continue;
+      if (!hasSupportedExtension(name)) continue;
+      sounds.push({ label: displayLabel(name), filename: name });
+    }
+    sounds.sort((a, b) =>
+      a.label.localeCompare(b.label, undefined, { sensitivity: "base" }),
+    );
+    return { sounds };
+  } catch {
+    return { sounds: [] };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Route definitions
+// ---------------------------------------------------------------------------
+
+export const ROUTES: RouteDefinition[] = [
+  {
+    operationId: "sounds_config_get",
+    endpoint: "sounds/config",
+    method: "GET",
+    policy: {
+      requiredScopes: ["settings.read"],
+      allowedPrincipalTypes: ACTOR_PRINCIPALS,
+    },
+    summary: "Get sounds configuration",
+    description:
+      "Return the sounds configuration from data/sounds/config.json, normalised with defaults.",
+    tags: ["sounds"],
+    responseBody: soundsConfigSchema,
+    handler: handleGetSoundsConfig,
+  },
+  {
+    operationId: "sounds_config_put",
+    endpoint: "sounds/config",
+    method: "PUT",
+    policy: {
+      requiredScopes: ["settings.write"],
+      allowedPrincipalTypes: ACTOR_PRINCIPALS,
+    },
+    summary: "Update sounds configuration",
+    description: "Replace the sounds configuration in data/sounds/config.json.",
+    tags: ["sounds"],
+    requestBody: soundsConfigSchema,
+    responseBody: soundsConfigSchema,
+    handler: handlePutSoundsConfig,
+  },
+  {
+    operationId: "sounds_available_get",
+    endpoint: "sounds/available",
+    method: "GET",
+    policy: {
+      requiredScopes: ["settings.read"],
+      allowedPrincipalTypes: ACTOR_PRINCIPALS,
+    },
+    summary: "List available sound files",
+    description:
+      "Return audio files in data/sounds/ that can be assigned to sound events.",
+    tags: ["sounds"],
+    responseBody: z.object({
+      sounds: z.array(availableSoundSchema),
+    }),
+    handler: handleListAvailableSounds,
+  },
+];

package/src/runtime/routes/surface-action-routes.ts

@@ -11,16 +11,24 @@ import { z } from "zod";
 
 import type { ChannelId } from "../../channels/types.js";
 import { isHttpAuthDisabled } from "../../config/env.js";
+import { findGuardianForChannel } from "../../contacts/contact-store.js";
 import { getLogger } from "../../util/logger.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../assistant-scope.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
+import { processGuardianDecision } from "../guardian-action-service.js";
 import { healGuardianBindingDrift } from "../guardian-vellum-migration.js";
 import { resolveLocalTrustContext } from "../local-actor-identity.js";
 import {
   resolveTrustContext,
   withSourceChannel,
 } from "../trust-context-resolver.js";
-import { BadRequestError, InternalError, NotFoundError, RouteError } from "./errors.js";
+import { parseCallbackData } from "./channel-route-shared.js";
+import {
+  BadRequestError,
+  InternalError,
+  NotFoundError,
+  RouteError,
+} from "./errors.js";
 import { resolveSurfaceConversation } from "./surface-conversation-resolver.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
@@ -95,6 +103,9 @@ async function handleSurfaceAction({
 }: RouteHandlerArgs): Promise<{
   ok: boolean;
   conversationId?: string;
+  applied?: boolean;
+  reason?: string;
+  replyText?: string;
 }> {
   const conversationId = body?.conversationId as string | null | undefined;
   const surfaceId = body?.surfaceId as string | undefined;
@@ -111,6 +122,59 @@ async function handleSurfaceAction({
     throw new BadRequestError("conversationId must be a string");
   }
 
+  // Intercept access-request approval actions (apr:<requestId>:<action>)
+  // before conversation resolution — these are cross-conversation decisions
+  // that route through the canonical guardian decision primitive.
+  const aprDecision = parseCallbackData(actionId, "vellum");
+  if (aprDecision) {
+    // Resolve the actor's guardian principal ID. In dev mode the synthetic
+    // "dev-bypass" principal won't match the real guardian binding, so fall
+    // back to the local guardian binding — mirrors guardian-action-routes.ts.
+    let guardianPrincipalId: string | undefined =
+      headers?.["x-vellum-actor-principal-id"] ?? undefined;
+    if (
+      isHttpAuthDisabled() &&
+      headers?.["x-vellum-actor-principal-id"] === "dev-bypass"
+    ) {
+      const binding = findGuardianForChannel("vellum");
+      guardianPrincipalId = binding?.contact.principalId ?? undefined;
+    }
+
+    const result = await processGuardianDecision({
+      requestId: aprDecision.requestId!,
+      action: aprDecision.action,
+      conversationId: conversationId ?? undefined,
+      channel: "vellum",
+      actorContext: {
+        actorPrincipalId: guardianPrincipalId,
+        guardianPrincipalId,
+      },
+    });
+
+    if (!result.ok) {
+      throw new BadRequestError(result.message);
+    }
+    if (!result.applied) {
+      log.warn(
+        { actionId, requestId: aprDecision.requestId, reason: result.reason },
+        "Access request decision not applied",
+      );
+    } else {
+      log.info(
+        { actionId, requestId: result.requestId },
+        "Access request decision applied via surface action",
+      );
+    }
+    return {
+      ok: true,
+      applied: result.applied,
+      ...(!result.applied ? { reason: result.reason } : {}),
+      ...(result.applied && result.replyText
+        ? { replyText: result.replyText }
+        : {}),
+    };
+  }
+
   const conversation = await resolveSurfaceConversation(
     conversationId,
     surfaceId,
@@ -255,6 +319,24 @@ export const ROUTES: RouteDefinition[] = [
           "Id of a newly launched conversation when the action dispatched one. Omitted otherwise.",
         )
         .optional(),
+      applied: z
+        .boolean()
+        .describe(
+          "Whether the action was applied. Present only for guardian decision actions (apr:*). False when the request was already resolved, expired, or the actor lacks permission.",
+        )
+        .optional(),
+      reason: z
+        .string()
+        .describe(
+          "Explanation when applied is false (e.g. 'already_resolved', 'expired', 'principal_mismatch').",
+        )
+        .optional(),
+      replyText: z
+        .string()
+        .describe(
+          "Guardian-facing reply from the resolver (e.g. verification code for access-request approvals). Present only when applied is true and the resolver produced a reply.",
+        )
+        .optional(),
     }),
     handler: handleSurfaceAction,
   },
@@ -270,9 +352,7 @@ export const ROUTES: RouteDefinition[] = [
     description: "Revert the most recent action on a surface.",
     tags: ["surfaces"],
     requestBody: z.object({
-      conversationId: z
-        .string()
-        .describe("Conversation that owns the surface"),
+      conversationId: z.string().describe("Conversation that owns the surface"),
     }),
     responseBody: z.object({
       ok: z.boolean(),