@vellumai/assistant 0.4.21 → 0.4.23

package/src/daemon/daemon-control.ts

@@ -251,6 +251,9 @@ function releaseStartupLock(): void {
   try { unlinkSync(getStartupLockPath()); } catch { /* already removed */ }
 }
 
+// NOTE: startDaemon() is the assistant-side daemon lifecycle manager.
+// It should eventually converge with cli/src/lib/local.ts::startLocalDaemon
+// which is the CLI-side equivalent.
 export async function startDaemon(): Promise<{
   pid: number;
   alreadyRunning: boolean;

package/src/daemon/handlers/browser.ts

@@ -1,54 +1,8 @@
-import { browserManager, SCREENCAST_HEIGHT,SCREENCAST_WIDTH } from '../../tools/browser/browser-manager.js';
-import { defineHandlers,log } from './shared.js';
+import { browserManager } from "../../tools/browser/browser-manager.js";
+import { defineHandlers } from "./shared.js";
 
 export const browserHandlers = defineHandlers({
   browser_cdp_response: (msg) => {
     browserManager.resolveCDPResponse(msg.sessionId, msg.success, msg.declined);
   },
-
-  browser_user_click: async (msg) => {
-    try {
-      const page = await browserManager.getOrCreateSessionPage(msg.sessionId);
-      const viewport = await page.evaluate('(() => ({ vw: window.innerWidth, vh: window.innerHeight }))()') as { vw: number; vh: number };
-      const scale = Math.min(SCREENCAST_WIDTH / viewport.vw, SCREENCAST_HEIGHT / viewport.vh);
-      const pageX = msg.x / scale;
-      const pageY = msg.y / scale;
-      const options: Record<string, unknown> = {};
-      if (msg.button === 'right') options.button = 'right';
-      if (msg.doubleClick) options.clickCount = 2;
-      await page.mouse.click(pageX, pageY, options);
-    } catch (err) {
-      log.warn({ err, sessionId: msg.sessionId }, 'Failed to forward user click');
-    }
-  },
-
-  browser_user_scroll: async (msg) => {
-    try {
-      const page = await browserManager.getOrCreateSessionPage(msg.sessionId);
-      await page.mouse.wheel(msg.deltaX, msg.deltaY);
-    } catch (err) {
-      log.warn({ err, sessionId: msg.sessionId }, 'Failed to forward user scroll');
-    }
-  },
-
-  browser_user_keypress: async (msg) => {
-    try {
-      const page = await browserManager.getOrCreateSessionPage(msg.sessionId);
-      const combo = msg.modifiers?.length ? [...msg.modifiers, msg.key].join('+') : msg.key;
-      await page.keyboard.press(combo);
-    } catch (err) {
-      log.warn({ err, sessionId: msg.sessionId }, 'Failed to forward user keypress');
-    }
-  },
-
-  browser_interactive_mode: (msg, socket, ctx) => {
-    log.info({ sessionId: msg.sessionId, enabled: msg.enabled }, 'Interactive mode toggled');
-    browserManager.setInteractiveMode(msg.sessionId, msg.enabled);
-    ctx.send(socket, {
-      type: 'browser_interactive_mode_changed',
-      sessionId: msg.sessionId,
-      surfaceId: msg.surfaceId,
-      enabled: msg.enabled,
-    });
-  },
 });

package/src/daemon/handlers/config-voice.ts

@@ -1,7 +1,7 @@
-import * as net from 'node:net';
+import * as net from "node:net";
 
-import type { VoiceConfigUpdateRequest } from '../ipc-contract/settings.js';
-import { defineHandlers, type HandlerContext, log } from './shared.js';
+import type { VoiceConfigUpdateRequest } from "../ipc-contract/settings.js";
+import { defineHandlers, type HandlerContext, log } from "./shared.js";
 
 /**
  * Send a client_settings_update message to all connected clients.
@@ -14,16 +14,16 @@ export function broadcastClientSettingsUpdate(
   ctx: HandlerContext,
 ): void {
   ctx.broadcast({
-    type: 'client_settings_update',
+    type: "client_settings_update",
     key,
     value,
   });
-  log.info({ key, value }, 'Broadcast client_settings_update');
+  log.info({ key, value }, "Broadcast client_settings_update");
 }
 
 // ── Activation key validation ────────────────────────────────────────
 
-const VALID_ACTIVATION_KEYS = ['fn', 'ctrl', 'fn_shift', 'none'] as const;
+const VALID_ACTIVATION_KEYS = ["fn", "ctrl", "fn_shift", "none"] as const;
 export type ActivationKey = (typeof VALID_ACTIVATION_KEYS)[number];
 
 /**
@@ -31,48 +31,167 @@ export type ActivationKey = (typeof VALID_ACTIVATION_KEYS)[number];
  * Case-insensitive matching is applied by the caller.
  */
 const NATURAL_LANGUAGE_MAP: Record<string, ActivationKey> = {
-  fn: 'fn',
-  globe: 'fn',
-  'fn key': 'fn',
-  'globe key': 'fn',
-  ctrl: 'ctrl',
-  control: 'ctrl',
-  'ctrl key': 'ctrl',
-  'control key': 'ctrl',
-  fn_shift: 'fn_shift',
-  'fn+shift': 'fn_shift',
-  'fn shift': 'fn_shift',
-  'shift+fn': 'fn_shift',
-  none: 'none',
-  off: 'none',
-  disabled: 'none',
-  disable: 'none',
+  fn: "fn",
+  globe: "fn",
+  "fn key": "fn",
+  "globe key": "fn",
+  ctrl: "ctrl",
+  control: "ctrl",
+  "ctrl key": "ctrl",
+  "control key": "ctrl",
+  fn_shift: "fn_shift",
+  "fn+shift": "fn_shift",
+  "fn shift": "fn_shift",
+  "shift+fn": "fn_shift",
+  none: "none",
+  off: "none",
+  disabled: "none",
+  disable: "none",
 };
 
+// ── PTTActivator JSON validation ─────────────────────────────────────
+
+const VALID_KINDS = [
+  "modifierOnly",
+  "key",
+  "modifierKey",
+  "mouseButton",
+  "none",
+] as const;
+type PTTKind = (typeof VALID_KINDS)[number];
+
+interface PTTActivatorPayload {
+  kind: PTTKind;
+  keyCode?: number | null;
+  modifierFlags?: number | null;
+  mouseButton?: number | null;
+}
+
+/**
+ * Validate a parsed PTTActivator JSON payload.
+ * Returns an error message if invalid, or null if valid.
+ */
+function validatePTTActivator(payload: PTTActivatorPayload): string | null {
+  if (!VALID_KINDS.includes(payload.kind)) {
+    return `Invalid kind "${payload.kind}". Valid values: ${VALID_KINDS.join(", ")}`;
+  }
+
+  // Enforce numeric types for fields that the Swift client decodes as numbers.
+  // Without this, JS coercion lets string values like "96" pass range checks
+  // but the macOS client fails to decode them as UInt16/Int/UInt.
+  if (payload.keyCode != null && typeof payload.keyCode !== "number") {
+    return `keyCode must be a number, got ${typeof payload.keyCode}`;
+  }
+  if (
+    payload.modifierFlags != null &&
+    typeof payload.modifierFlags !== "number"
+  ) {
+    return `modifierFlags must be a number, got ${typeof payload.modifierFlags}`;
+  }
+  if (payload.mouseButton != null && typeof payload.mouseButton !== "number") {
+    return `mouseButton must be a number, got ${typeof payload.mouseButton}`;
+  }
+
+  switch (payload.kind) {
+    case "modifierOnly":
+      if (payload.modifierFlags == null) {
+        return "modifierOnly requires modifierFlags";
+      }
+      if (payload.keyCode != null || payload.mouseButton != null) {
+        return "modifierOnly must not have keyCode or mouseButton";
+      }
+      break;
+
+    case "key":
+      if (payload.keyCode == null) {
+        return "key requires keyCode";
+      }
+      if (payload.keyCode < 0 || payload.keyCode > 255) {
+        return `keyCode must be 0-255, got ${payload.keyCode}`;
+      }
+      if (payload.mouseButton != null) {
+        return "key must not have mouseButton";
+      }
+      break;
+
+    case "modifierKey":
+      if (payload.keyCode == null) {
+        return "modifierKey requires keyCode";
+      }
+      if (payload.keyCode < 0 || payload.keyCode > 255) {
+        return `keyCode must be 0-255, got ${payload.keyCode}`;
+      }
+      if (payload.modifierFlags == null) {
+        return "modifierKey requires modifierFlags";
+      }
+      if (payload.mouseButton != null) {
+        return "modifierKey must not have mouseButton";
+      }
+      break;
+
+    case "mouseButton":
+      if (payload.mouseButton == null) {
+        return "mouseButton requires mouseButton field";
+      }
+      if (payload.mouseButton < 2) {
+        return `mouseButton must be >= 2 (left=0, right=1 are reserved), got ${payload.mouseButton}`;
+      }
+      if (payload.keyCode != null) {
+        return "mouseButton must not have keyCode";
+      }
+      break;
+
+    case "none":
+      // No required fields
+      break;
+  }
+
+  return null;
+}
+
 /**
  * Validate and normalise a user-provided activation key string.
- * Accepts both canonical enum values and natural-language variants.
+ * Accepts legacy enum values, natural-language variants, and PTTActivator JSON.
  * Returns the canonical value on success, or an error message on failure.
  */
 export function normalizeActivationKey(
   input: string,
-): { ok: true; value: ActivationKey } | { ok: false; reason: string } {
-  const trimmed = input.trim().toLowerCase();
+): { ok: true; value: string } | { ok: false; reason: string } {
+  const trimmed = input.trim();
+
+  // Try JSON parse first (PTTActivator payloads start with '{')
+  if (trimmed.startsWith("{")) {
+    try {
+      const parsed = JSON.parse(trimmed) as PTTActivatorPayload;
+      const error = validatePTTActivator(parsed);
+      if (error) {
+        return { ok: false, reason: `Invalid PTTActivator: ${error}` };
+      }
+      // Pass through the validated JSON as-is
+      return { ok: true, value: trimmed };
+    } catch {
+      return {
+        ok: false,
+        reason: `Malformed PTTActivator JSON: ${input}`,
+      };
+    }
+  }
 
-  // Direct enum match
-  if ((VALID_ACTIVATION_KEYS as readonly string[]).includes(trimmed)) {
-    return { ok: true, value: trimmed as ActivationKey };
+  // Legacy: direct enum match
+  const lower = trimmed.toLowerCase();
+  if ((VALID_ACTIVATION_KEYS as readonly string[]).includes(lower)) {
+    return { ok: true, value: lower as ActivationKey };
   }
 
-  // Natural-language match
-  const mapped = NATURAL_LANGUAGE_MAP[trimmed];
+  // Legacy: natural-language match
+  const mapped = NATURAL_LANGUAGE_MAP[lower];
   if (mapped) {
     return { ok: true, value: mapped };
   }
 
   return {
     ok: false,
-    reason: `Invalid activation key "${input}". Valid values: fn (Fn/Globe key), ctrl (Control key), fn_shift (Fn+Shift), none (disable PTT).`,
+    reason: `Invalid activation key "${input}". Valid values: fn (Fn/Globe key), ctrl (Control key), fn_shift (Fn+Shift), none (disable PTT), or a PTTActivator JSON object.`,
   };
 }
 
@@ -91,8 +210,11 @@ export function handleVoiceConfigUpdate(
     return;
   }
 
-  broadcastClientSettingsUpdate('activationKey', result.value, ctx);
-  log.info({ activationKey: result.value }, 'Voice config updated: activation key');
+  broadcastClientSettingsUpdate("activationKey", result.value, ctx);
+  log.info(
+    { activationKey: result.value },
+    "Voice config updated: activation key",
+  );
 }
 
 export const voiceHandlers = defineHandlers({