@vellumai/assistant 0.4.13 → 0.4.15

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

@@ -1,14 +1,22 @@
-import { API_KEY_PROVIDERS, getConfig, invalidateConfigCache } from '../../config/loader.js';
-import { initializeProviders } from '../../providers/registry.js';
-import { deleteSecureKey, setSecureKey } from '../../security/secure-keys.js';
-import { assertMetadataWritable, deleteCredentialMetadata, upsertCredentialMetadata } from '../../tools/credentials/metadata-store.js';
-import { getLogger } from '../../util/logger.js';
-import { httpError } from '../http-errors.js';
+import {
+  API_KEY_PROVIDERS,
+  getConfig,
+  invalidateConfigCache,
+} from "../../config/loader.js";
+import { initializeProviders } from "../../providers/registry.js";
+import { deleteSecureKey, setSecureKey } from "../../security/secure-keys.js";
+import {
+  assertMetadataWritable,
+  deleteCredentialMetadata,
+  upsertCredentialMetadata,
+} from "../../tools/credentials/metadata-store.js";
+import { getLogger } from "../../util/logger.js";
+import { httpError } from "../http-errors.js";
 
-const log = getLogger('runtime-http');
+const log = getLogger("runtime-http");
 
 export async function handleAddSecret(req: Request): Promise<Response> {
-  const body = await req.json() as {
+  const body = (await req.json()) as {
     type?: string;
     name?: string;
     value?: string;
@@ -16,35 +24,49 @@ export async function handleAddSecret(req: Request): Promise<Response> {
 
   const { type, name, value } = body;
 
-  if (!type || typeof type !== 'string') {
-    return httpError('BAD_REQUEST', 'type is required', 400);
+  if (!type || typeof type !== "string") {
+    return httpError("BAD_REQUEST", "type is required", 400);
   }
-  if (!name || typeof name !== 'string') {
-    return httpError('BAD_REQUEST', 'name is required', 400);
+  if (!name || typeof name !== "string") {
+    return httpError("BAD_REQUEST", "name is required", 400);
   }
-  if (!value || typeof value !== 'string') {
-    return httpError('BAD_REQUEST', 'value is required', 400);
+  if (!value || typeof value !== "string") {
+    return httpError("BAD_REQUEST", "value is required", 400);
   }
 
   try {
-    if (type === 'api_key') {
-      if (!API_KEY_PROVIDERS.includes(name as typeof API_KEY_PROVIDERS[number])) {
-        return httpError('BAD_REQUEST', `Unknown API key provider: ${name}. Valid providers: ${API_KEY_PROVIDERS.join(', ')}`, 400);
+    if (type === "api_key") {
+      if (
+        !API_KEY_PROVIDERS.includes(name as (typeof API_KEY_PROVIDERS)[number])
+      ) {
+        return httpError(
+          "BAD_REQUEST",
+          `Unknown API key provider: ${name}. Valid providers: ${API_KEY_PROVIDERS.join(", ")}`,
+          400,
+        );
       }
       const stored = setSecureKey(name, value);
       if (!stored) {
-        return httpError('INTERNAL_ERROR', 'Failed to store API key in secure storage', 500);
+        return httpError(
+          "INTERNAL_ERROR",
+          "Failed to store API key in secure storage",
+          500,
+        );
       }
       invalidateConfigCache();
       initializeProviders(getConfig());
-      log.info({ provider: name }, 'API key updated via HTTP');
+      log.info({ provider: name }, "API key updated via HTTP");
       return Response.json({ success: true, type, name }, { status: 201 });
     }
 
-    if (type === 'credential') {
-      const colonIdx = name.indexOf(':');
+    if (type === "credential") {
+      const colonIdx = name.indexOf(":");
       if (colonIdx < 1 || colonIdx === name.length - 1) {
-        return httpError('BAD_REQUEST', 'For credential type, name must be in "service:field" format (e.g. "github:api_token")', 400);
+        return httpError(
+          "BAD_REQUEST",
+          'For credential type, name must be in "service:field" format (e.g. "github:api_token")',
+          400,
+        );
       }
       assertMetadataWritable();
       const service = name.slice(0, colonIdx);
@@ -52,72 +74,95 @@ export async function handleAddSecret(req: Request): Promise<Response> {
       const key = `credential:${service}:${field}`;
       const stored = setSecureKey(key, value);
       if (!stored) {
-        return httpError('INTERNAL_ERROR', 'Failed to store credential in secure storage', 500);
+        return httpError(
+          "INTERNAL_ERROR",
+          "Failed to store credential in secure storage",
+          500,
+        );
       }
       upsertCredentialMetadata(service, field, {});
-      log.info({ service, field }, 'Credential added via HTTP');
+      log.info({ service, field }, "Credential added via HTTP");
       return Response.json({ success: true, type, name }, { status: 201 });
     }
 
-    return httpError('BAD_REQUEST', `Unknown secret type: ${type}. Valid types: api_key, credential`, 400);
+    return httpError(
+      "BAD_REQUEST",
+      `Unknown secret type: ${type}. Valid types: api_key, credential`,
+      400,
+    );
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    log.error({ err, type, name }, 'Failed to add secret via HTTP');
-    return httpError('INTERNAL_ERROR', message, 500);
+    log.error({ err, type, name }, "Failed to add secret via HTTP");
+    return httpError("INTERNAL_ERROR", message, 500);
   }
 }
 
 export async function handleDeleteSecret(req: Request): Promise<Response> {
-  const body = await req.json() as {
+  const body = (await req.json()) as {
     type?: string;
     name?: string;
   };
 
   const { type, name } = body;
 
-  if (!type || typeof type !== 'string') {
-    return httpError('BAD_REQUEST', 'type is required', 400);
+  if (!type || typeof type !== "string") {
+    return httpError("BAD_REQUEST", "type is required", 400);
   }
-  if (!name || typeof name !== 'string') {
-    return httpError('BAD_REQUEST', 'name is required', 400);
+  if (!name || typeof name !== "string") {
+    return httpError("BAD_REQUEST", "name is required", 400);
   }
 
   try {
-    if (type === 'api_key') {
-      if (!API_KEY_PROVIDERS.includes(name as typeof API_KEY_PROVIDERS[number])) {
-        return httpError('BAD_REQUEST', `Unknown API key provider: ${name}. Valid providers: ${API_KEY_PROVIDERS.join(', ')}`, 400);
+    if (type === "api_key") {
+      if (
+        !API_KEY_PROVIDERS.includes(name as (typeof API_KEY_PROVIDERS)[number])
+      ) {
+        return httpError(
+          "BAD_REQUEST",
+          `Unknown API key provider: ${name}. Valid providers: ${API_KEY_PROVIDERS.join(", ")}`,
+          400,
+        );
       }
       const deleted = deleteSecureKey(name);
       if (!deleted) {
-        return httpError('NOT_FOUND', `API key not found: ${name}`, 404);
+        return httpError("NOT_FOUND", `API key not found: ${name}`, 404);
       }
       invalidateConfigCache();
       initializeProviders(getConfig());
-      log.info({ provider: name }, 'API key deleted via HTTP');
+      log.info({ provider: name }, "API key deleted via HTTP");
       return Response.json({ success: true, type, name });
     }
 
-    if (type === 'credential') {
-      const colonIdx = name.indexOf(':');
+    if (type === "credential") {
+      const colonIdx = name.indexOf(":");
       if (colonIdx < 1 || colonIdx === name.length - 1) {
-        return httpError('BAD_REQUEST', 'For credential type, name must be in "service:field" format (e.g. "github:api_token")', 400);
+        return httpError(
+          "BAD_REQUEST",
+          'For credential type, name must be in "service:field" format (e.g. "github:api_token")',
+          400,
+        );
       }
       const service = name.slice(0, colonIdx);
       const field = name.slice(colonIdx + 1);
+      assertMetadataWritable();
       const key = `credential:${service}:${field}`;
       const deleted = deleteSecureKey(key);
       if (!deleted) {
-        return httpError('NOT_FOUND', `Credential not found: ${name}`, 404);
+        return httpError("NOT_FOUND", `Credential not found: ${name}`, 404);
       }
       deleteCredentialMetadata(service, field);
-      log.info({ service, field }, 'Credential deleted via HTTP');
+      log.info({ service, field }, "Credential deleted via HTTP");
       return Response.json({ success: true, type, name });
     }
 
-    return httpError('BAD_REQUEST', `Unknown secret type: ${type}. Valid types: api_key, credential`, 400);
+    return httpError(
+      "BAD_REQUEST",
+      `Unknown secret type: ${type}. Valid types: api_key, credential`,
+      400,
+    );
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    log.error({ err, type, name }, 'Failed to delete secret via HTTP');
-    return httpError('INTERNAL_ERROR', message, 500);
+    log.error({ err, type, name }, "Failed to delete secret via HTTP");
+    return httpError("INTERNAL_ERROR", message, 500);
   }
 }

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

@@ -4,13 +4,23 @@
  * POST /v1/surface-actions — dispatch a surface action to an active session.
  * Requires the session to already exist (does not create new sessions).
  */
-import type { Session } from "../../daemon/session.js";
 import { getLogger } from "../../util/logger.js";
 import { httpError } from "../http-errors.js";
 
 const log = getLogger("surface-action-routes");
 
-export type SessionLookup = (sessionId: string) => Session | undefined;
+/** Any object that can handle a surface action (Session or ComputerUseSession). */
+interface SurfaceActionTarget {
+  handleSurfaceAction(
+    surfaceId: string,
+    actionId: string,
+    data?: Record<string, unknown>,
+  ): void;
+}
+
+export type SessionLookup = (
+  sessionId: string,
+) => SurfaceActionTarget | undefined;
 
 /**
  * POST /v1/surface-actions — handle a UI surface action.

package/src/runtime/routes/trust-rules-routes.ts

@@ -123,6 +123,19 @@ export async function handleUpdateTrustRuleManage(
     priority?: number;
   };
 
+  if (body.decision !== undefined) {
+    const validDecisions = ["allow", "deny", "ask"] as const;
+    if (
+      !validDecisions.includes(body.decision as (typeof validDecisions)[number])
+    ) {
+      return httpError(
+        "BAD_REQUEST",
+        "decision must be one of: allow, deny, ask",
+        400,
+      );
+    }
+  }
+
   try {
     updateRule(id, {
       tool: body.tool,

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

@@ -38,7 +38,7 @@ import { syncTwilioWebhooks } from '../../daemon/handlers/config-ingress.js';
 import type { IngressConfig } from '../../inbound/public-ingress-urls.js';
 import { deleteSecureKey, getSecureKey, setSecureKey } from '../../security/secure-keys.js';
 import { deleteCredentialMetadata, upsertCredentialMetadata } from '../../tools/credentials/metadata-store.js';
-import { readHttpToken } from '../../util/platform.js';
+import { mintDaemonDeliveryToken } from '../auth/token-service.js';
 
 // ---------------------------------------------------------------------------
 // Shared helpers
@@ -716,14 +716,14 @@ export async function handleSmsSendTest(req: Request): Promise<Response> {
   const text = body.text || 'Test SMS from your Vellum assistant';
 
   // Send via gateway's /deliver/sms endpoint
-  const bearerToken = readHttpToken();
+  const bearerToken = mintDaemonDeliveryToken();
   const gatewayUrl = getGatewayInternalBaseUrl();
 
   const sendResp = await fetch(`${gatewayUrl}/deliver/sms`, {
     method: 'POST',
     headers: {
       'Content-Type': 'application/json',
-      ...(bearerToken ? { Authorization: `Bearer ${bearerToken}` } : {}),
+      Authorization: `Bearer ${bearerToken}`,
     },
     body: JSON.stringify({ to, text }),
     signal: AbortSignal.timeout(30_000),

package/src/runtime/session-approval-overrides.ts

@@ -0,0 +1,86 @@
+/**
+ * Per-conversation temporary approval overrides.
+ *
+ * When a user chooses `allow_thread` or `allow_10m`, the session records a
+ * temporary approval mode scoped to the conversation. Subsequent tool-use
+ * confirmations within the same conversation can check this state to
+ * auto-approve without prompting.
+ *
+ * State is in-memory only -- it does not survive daemon restarts, which is
+ * the desired behavior for temporary approvals. Thread-scoped overrides
+ * persist until the session ends or the mode is explicitly cleared. Timed
+ * overrides expire after their TTL (checked at read time, no background sweep).
+ */
+
+export type TemporaryApprovalMode =
+  | { kind: "thread" }
+  | { kind: "timed"; expiresAt: number };
+
+const DEFAULT_TIMED_DURATION_MS = 10 * 60 * 1000; // 10 minutes
+
+const store = new Map<string, TemporaryApprovalMode>();
+
+/**
+ * Set thread-scoped temporary approval for a conversation.
+ * Remains active until explicitly cleared or session ends.
+ * Replaces any existing mode for the conversation.
+ */
+export function setThreadMode(conversationId: string): void {
+  store.set(conversationId, { kind: "thread" });
+}
+
+/**
+ * Set time-limited temporary approval for a conversation.
+ * Replaces any existing mode for the conversation.
+ *
+ * @param conversationId - The conversation to scope the override to
+ * @param durationMs - How long the override lasts (defaults to 10 minutes)
+ */
+export function setTimedMode(
+  conversationId: string,
+  durationMs: number = DEFAULT_TIMED_DURATION_MS,
+): void {
+  store.set(conversationId, {
+    kind: "timed",
+    expiresAt: Date.now() + durationMs,
+  });
+}
+
+/**
+ * Clear any temporary approval mode for a conversation.
+ */
+export function clearMode(conversationId: string): void {
+  store.delete(conversationId);
+}
+
+/**
+ * Get the effective temporary approval mode for a conversation.
+ *
+ * Returns undefined if no mode is set or if a timed mode has expired.
+ * Expired timed modes are cleaned up lazily on read.
+ */
+export function getEffectiveMode(
+  conversationId: string,
+): TemporaryApprovalMode | undefined {
+  const mode = store.get(conversationId);
+  if (!mode) return undefined;
+
+  if (mode.kind === "timed" && Date.now() >= mode.expiresAt) {
+    store.delete(conversationId);
+    return undefined;
+  }
+
+  return mode;
+}
+
+/**
+ * Check whether a conversation has an active (non-expired) temporary approval.
+ */
+export function hasActiveOverride(conversationId: string): boolean {
+  return getEffectiveMode(conversationId) !== undefined;
+}
+
+/** Clear all overrides. Useful for testing. */
+export function clearAll(): void {
+  store.clear();
+}

package/src/security/keychain-to-encrypted-migration.ts

@@ -35,6 +35,7 @@ export function migrateKeychainToEncrypted(): void {
   if (encryptedStore.getKey(MIGRATION_MARKER) === "true") return;
 
   let migrated = 0;
+  let hadErrors = false;
   const allKeys = [...API_KEY_PROVIDERS, ...CREDENTIAL_KEYS];
 
   for (const account of allKeys) {
@@ -45,10 +46,16 @@ export function migrateKeychainToEncrypted(): void {
         migrated++;
       }
     } catch {
-      // Keychain unavailable or locked -- skip silently
+      hadErrors = true;
+      log.warn({ account }, "Keychain read failed during migration");
     }
   }
 
+  if (hadErrors) {
+    log.warn("Skipping migration marker — will retry on next startup");
+    return;
+  }
+
   encryptedStore.setKey(MIGRATION_MARKER, "true");
   if (migrated > 0) {
     log.info(

package/src/skills/frontmatter.ts

@@ -34,15 +34,55 @@ export function parseFrontmatterFields(
   const frontmatter = match[1];
   const fields: Record<string, string> = {};
 
-  for (const line of frontmatter.split(/\r?\n/)) {
+  const lines = frontmatter.split(/\r?\n/);
+  let currentKey: string | undefined;
+  let continuationLines: string[] = [];
+
+  function flushContinuation() {
+    if (currentKey !== undefined) {
+      if (continuationLines.length > 0) {
+        // Join continuation lines, then strip trailing commas before closing
+        // braces/brackets so that prettier-formatted JSON remains valid for JSON.parse.
+        fields[currentKey] = continuationLines
+          .map((l) => l.trim())
+          .join(" ")
+          .replace(/,\s*([}\]])/g, "$1");
+      } else {
+        fields[currentKey] = "";
+      }
+    }
+    currentKey = undefined;
+    continuationLines = [];
+  }
+
+  for (const line of lines) {
     const trimmed = line.trim();
     if (!trimmed || trimmed.startsWith("#")) continue;
+
+    // Continuation line: indented and no top-level key: pattern
+    // (i.e. starts with whitespace and either has no colon or the colon
+    // is inside braces/quotes — heuristic: line starts with space/tab)
+    if (currentKey !== undefined && /^\s/.test(line)) {
+      continuationLines.push(trimmed);
+      continue;
+    }
+
+    // Flush any pending multiline value
+    flushContinuation();
+
     const separatorIndex = trimmed.indexOf(":");
     if (separatorIndex === -1) continue;
 
     const key = trimmed.slice(0, separatorIndex).trim();
     let value = trimmed.slice(separatorIndex + 1).trim();
 
+    if (!value) {
+      // Value may continue on subsequent indented lines
+      currentKey = key;
+      continuationLines = [];
+      continue;
+    }
+
     const isDoubleQuoted = value.startsWith('"') && value.endsWith('"');
     const isSingleQuoted = value.startsWith("'") && value.endsWith("'");
     if (isDoubleQuoted || isSingleQuoted) {
@@ -61,5 +101,8 @@ export function parseFrontmatterFields(
     fields[key] = value;
   }
 
+  // Flush any trailing multiline value
+  flushContinuation();
+
   return { fields, body: content.slice(match[0].length) };
 }