@vellumai/assistant 0.4.26 → 0.4.30

package/src/util/spawn.ts

@@ -0,0 +1,48 @@
+/**
+ * Shared spawn-with-timeout helper used by media-processing and transcribe tools.
+ */
+
+/** Full video preprocessing: mpdecimate analysis, frame extraction, palette analysis. Longest operation. */
+export const FFMPEG_PREPROCESS_TIMEOUT_MS = 600_000;
+
+/** Clip extraction via stream copy. Moderate timeout — no re-encoding needed. */
+export const FFMPEG_CLIP_TIMEOUT_MS = 300_000;
+
+/** Audio transcoding/splitting to WAV for Whisper. Relatively fast operation. */
+export const FFMPEG_TRANSCODE_TIMEOUT_MS = 120_000;
+
+/** Metadata extraction via ffprobe. Very fast — just reads headers. */
+export const FFPROBE_TIMEOUT_MS = 15_000;
+
+/** Palette/color analysis on a single frame via ffmpeg. Moderate — heavier than metadata reads. */
+export const FFMPEG_PALETTE_TIMEOUT_MS = 30_000;
+
+export function spawnWithTimeout(
+  cmd: string[],
+  timeoutMs: number,
+): Promise<{ exitCode: number; stdout: string; stderr: string }> {
+  return new Promise((resolve, reject) => {
+    // Augment PATH so Homebrew-installed tools (ffmpeg, ffprobe, whisper-cpp)
+    // are found even when the daemon runs as a bundled binary with minimal PATH.
+    const proc = Bun.spawn(cmd, {
+      stdout: "pipe",
+      stderr: "pipe",
+      env: {
+        ...process.env,
+        PATH: [process.env.PATH, "/opt/homebrew/bin", "/usr/local/bin"]
+          .filter(Boolean)
+          .join(":"),
+      },
+    });
+    const timer = setTimeout(() => {
+      proc.kill();
+      reject(new Error(`Process timed out after ${timeoutMs}ms: ${cmd[0]}`));
+    }, timeoutMs);
+    proc.exited.then(async (exitCode) => {
+      clearTimeout(timer);
+      const stdout = await new Response(proc.stdout).text();
+      const stderr = await new Response(proc.stderr).text();
+      resolve({ exitCode, stdout, stderr });
+    });
+  });
+}

package/src/util/spinner.ts

@@ -4,12 +4,12 @@
  * Silently no-ops when stderr is not a TTY (e.g. redirected to file).
  */
 
-const FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-const DIM = '\x1b[2m';
-const RESET = '\x1b[0m';
+const FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const DIM = "\x1b[2m";
+const RESET = "\x1b[0m";
 
 export class Spinner {
-  private message = '';
+  private message = "";
   private startTime = 0;
   private frameIndex = 0;
   private timer: ReturnType<typeof setInterval> | null = null;
@@ -38,14 +38,16 @@ export class Spinner {
       this.timer = null;
     }
     // Clear the spinner line
-    process.stderr.write('\r\x1b[K');
+    process.stderr.write("\r\x1b[K");
   }
 
   private render(): void {
     const frame = FRAMES[this.frameIndex % FRAMES.length];
     this.frameIndex++;
     const elapsed = Math.floor((Date.now() - this.startTime) / 1000);
-    const timeStr = elapsed > 0 ? ` (${elapsed}s)` : '';
-    process.stderr.write(`\r\x1b[K${DIM}${frame} ${this.message}${timeStr}${RESET}`);
+    const timeStr = elapsed > 0 ? ` (${elapsed}s)` : "";
+    process.stderr.write(
+      `\r\x1b[K${DIM}${frame} ${this.message}${timeStr}${RESET}`,
+    );
   }
 }

package/src/util/time.ts

@@ -1,16 +1,29 @@
 export function timeAgo(timestamp: number): string {
   const seconds = Math.floor((Date.now() - timestamp) / 1000);
-  if (seconds < 60) return 'just now';
+  if (seconds < 60) return "just now";
   const minutes = Math.floor(seconds / 60);
   if (minutes < 60) return `${minutes}m ago`;
   const hours = Math.floor(minutes / 60);
   if (hours < 24) return `${hours}h ago`;
   const days = Math.floor(hours / 24);
-  if (days === 1) return 'yesterday';
+  if (days === 1) return "yesterday";
   if (days < 14) return `${days}d ago`;
   const weeks = Math.floor(days / 7);
   if (weeks < 8) return `${weeks}w ago`;
   const date = new Date(timestamp);
-  const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+  const months = [
+    "Jan",
+    "Feb",
+    "Mar",
+    "Apr",
+    "May",
+    "Jun",
+    "Jul",
+    "Aug",
+    "Sep",
+    "Oct",
+    "Nov",
+    "Dec",
+  ];
   return `${months[date.getMonth()]} ${date.getDate()}`;
 }

package/src/util/truncate.ts

@@ -1,5 +1,5 @@
 /** Truncate a string to `maxLen` characters, appending `suffix` if truncated. */
-export function truncate(str: string, maxLen: number, suffix = '...'): string {
+export function truncate(str: string, maxLen: number, suffix = "..."): string {
   if (str.length <= maxLen) return str;
   if (maxLen < suffix.length) return str.slice(0, maxLen);
   return str.slice(0, maxLen - suffix.length) + suffix;

package/src/util/voice-code.ts

@@ -6,7 +6,7 @@
  * stored — only its SHA-256 hash is persisted.
  */
 
-import { createHash, randomInt } from 'node:crypto';
+import { createHash, randomInt } from "node:crypto";
 
 /**
  * Generate a cryptographically random numeric code of the given length.
@@ -14,10 +14,12 @@ import { createHash, randomInt } from 'node:crypto';
  */
 export function generateVoiceCode(digits: number = 6): string {
   if (digits < 4 || digits > 10) {
-    throw new Error(`Voice code digit count must be between 4 and 10, got ${digits}`);
+    throw new Error(
+      `Voice code digit count must be between 4 and 10, got ${digits}`,
+    );
   }
   const min = Math.pow(10, digits - 1); // e.g. 100000 for 6 digits
-  const max = Math.pow(10, digits);     // e.g. 1000000 for 6 digits
+  const max = Math.pow(10, digits); // e.g. 1000000 for 6 digits
   return String(randomInt(min, max));
 }
 
@@ -25,5 +27,5 @@ export function generateVoiceCode(digits: number = 6): string {
  * SHA-256 hash a voice code for storage comparison.
  */
 export function hashVoiceCode(code: string): string {
-  return createHash('sha256').update(code).digest('hex');
+  return createHash("sha256").update(code).digest("hex");
 }

package/src/util/xml.ts

@@ -1,4 +1,8 @@
 /** Escape a string for safe inclusion in an XML/HTML attribute (double-quoted). */
 export function escapeXmlAttr(s: string): string {
-  return s.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+  return s
+    .replace(/&/g, "&amp;")
+    .replace(/"/g, "&quot;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;");
 }

package/src/version.ts

@@ -1,24 +1,28 @@
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
 
 function resolveVersion(): string {
   const envVersion = process.env.APP_VERSION;
 
   // When APP_VERSION is not set, we're in local development — return the dev
   // sentinel so Sentry (and similar) classify the session as "development".
-  if (!envVersion) return '0.0.0-dev';
+  if (!envVersion) return "0.0.0-dev";
 
   // CI sets APP_VERSION to the dev placeholder during builds; resolve it to
   // the package.json release version so Sentry gets a meaningful release tag.
-  if (envVersion === '0.0.0-dev') {
+  if (envVersion === "0.0.0-dev") {
     try {
-      const pkgPath = join(import.meta.dirname ?? __dirname, '..', 'package.json');
-      const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
-      if (pkg.version && typeof pkg.version === 'string') return pkg.version;
+      const pkgPath = join(
+        import.meta.dirname ?? __dirname,
+        "..",
+        "package.json",
+      );
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+      if (pkg.version && typeof pkg.version === "string") return pkg.version;
     } catch {
       // package.json missing or unreadable
     }
-    return '0.0.0-dev';
+    return "0.0.0-dev";
   }
 
   return envVersion;

package/src/watcher/engine.ts

@@ -5,12 +5,11 @@
  * and processes pending events through a background LLM conversation.
  */
 
-import { createConversation } from '../memory/conversation-store.js';
-import { GENERATING_TITLE, queueGenerateConversationTitle } from '../memory/conversation-title-service.js';
-import { checkForSequenceReplies } from '../sequence/reply-matcher.js';
-import { getLogger } from '../util/logger.js';
-import { MAX_CONSECUTIVE_ERRORS } from './constants.js';
-import { getWatcherProvider } from './provider-registry.js';
+import { bootstrapConversation } from "../memory/conversation-bootstrap.js";
+import { checkForSequenceReplies } from "../sequence/reply-matcher.js";
+import { getLogger } from "../util/logger.js";
+import { MAX_CONSECUTIVE_ERRORS } from "./constants.js";
+import { getWatcherProvider } from "./provider-registry.js";
 import {
   claimDueWatchers,
   completeWatcherPoll,
@@ -21,9 +20,9 @@ import {
   resetStuckWatchers,
   setWatcherConversationId,
   updateEventDisposition,
-} from './watcher-store.js';
+} from "./watcher-store.js";
 
-const log = getLogger('watcher-engine');
+const log = getLogger("watcher-engine");
 
 export type WatcherMessageProcessor = (
   conversationId: string,
@@ -52,7 +51,7 @@ export interface WatcherEngineHandle {
 export function initWatcherEngine(): void {
   const reset = resetStuckWatchers();
   if (reset > 0) {
-    log.info({ count: reset }, 'Reset stuck watchers to idle on startup');
+    log.info({ count: reset }, "Reset stuck watchers to idle on startup");
   }
 }
 
@@ -83,11 +82,18 @@ export async function runWatchersOnce(
       // Initialize watermark on first poll
       let watermark = watcher.watermark;
       if (!watermark) {
-        watermark = await provider.getInitialWatermark(watcher.credentialService);
-        log.info({ watcherId: watcher.id, watermark }, 'Initialized watermark');
+        watermark = await provider.getInitialWatermark(
+          watcher.credentialService,
+        );
+        log.info({ watcherId: watcher.id, watermark }, "Initialized watermark");
       }
 
-      const result = await provider.fetchNew(watcher.credentialService, watermark, config, watcher.id);
+      const result = await provider.fetchNew(
+        watcher.credentialService,
+        watermark,
+        config,
+        watcher.id,
+      );
 
       // Store new events with dedup
       let newEvents = 0;
@@ -107,7 +113,10 @@ export async function runWatchersOnce(
       }
 
       if (newEvents > 0) {
-        log.info({ watcherId: watcher.id, name: watcher.name, newEvents }, 'Detected new events');
+        log.info(
+          { watcherId: watcher.id, name: watcher.name, newEvents },
+          "Detected new events",
+        );
       }
 
       // Check new events for replies to active sequence enrollments
@@ -121,7 +130,10 @@ export async function runWatchersOnce(
             });
           }
         } catch (replyErr) {
-          log.warn({ err: replyErr, watcherId: watcher.id }, 'Reply matcher failed');
+          log.warn(
+            { err: replyErr, watcherId: watcher.id },
+            "Reply matcher failed",
+          );
         }
       }
 
@@ -132,18 +144,24 @@ export async function runWatchersOnce(
       processed++;
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      log.warn({ err, watcherId: watcher.id, name: watcher.name }, 'Watcher poll failed');
+      log.warn(
+        { err, watcherId: watcher.id, name: watcher.name },
+        "Watcher poll failed",
+      );
       failWatcherPoll(watcher.id, message);
 
       // Circuit breaker: disable after too many consecutive errors
-      if ((watcher.consecutiveErrors + 1) >= MAX_CONSECUTIVE_ERRORS) {
+      if (watcher.consecutiveErrors + 1 >= MAX_CONSECUTIVE_ERRORS) {
         const reason = `Disabled after ${MAX_CONSECUTIVE_ERRORS} consecutive errors. Last: ${message}`;
         disableWatcher(watcher.id, reason);
         // Do NOT call provider.cleanup() here — auto-disable is reversible.
         // If the watcher is re-enabled later, it must diff against the same
         // baseline to avoid missing events that occurred while disabled.
         // Cleanup is only correct on true deletion (see tools/watcher/delete.ts).
-        log.warn({ watcherId: watcher.id, name: watcher.name }, 'Watcher disabled by circuit breaker');
+        log.warn(
+          { watcherId: watcher.id, name: watcher.name },
+          "Watcher disabled by circuit breaker",
+        );
         notify({
           title: `Watcher disabled: ${watcher.name}`,
           body: reason,
@@ -163,41 +181,43 @@ export async function runWatchersOnce(
       // Get or create a background conversation for this watcher
       let conversationId = watcher.conversationId;
       if (!conversationId) {
-        const conv = createConversation({
-          title: GENERATING_TITLE,
-          threadType: 'background' as 'standard' | 'private',
-        });
-        queueGenerateConversationTitle({
-          conversationId: conv.id,
-          context: { origin: 'watcher', systemHint: `Watcher: ${watcher.name}` },
+        const conv = bootstrapConversation({
+          threadType: "background",
+          origin: "watcher",
+          systemHint: `Watcher: ${watcher.name}`,
         });
         conversationId = conv.id;
         setWatcherConversationId(watcher.id, conversationId);
       }
 
       // Build the LLM message with action prompt + event data
-      const eventSummaries = pendingEvents.map((e, i) =>
-        `Event ${i + 1} (id: ${e.id}):\n  Type: ${e.eventType}\n  Summary: ${e.summary}\n  Data: ${e.payloadJson}`,
-      ).join('\n\n');
+      const eventSummaries = pendingEvents
+        .map(
+          (e, i) =>
+            `Event ${i + 1} (id: ${e.id}):\n  Type: ${
+              e.eventType
+            }\n  Summary: ${e.summary}\n  Data: ${e.payloadJson}`,
+        )
+        .join("\n\n");
 
       const message = [
         watcher.actionPrompt,
-        '',
-        '---',
-        '',
+        "",
+        "---",
+        "",
         `${pendingEvents.length} new event(s) detected:`,
-        '',
+        "",
         eventSummaries,
-        '',
-        '---',
-        '',
-        'For each event, decide how to handle it and include a disposition block:',
-        '<watcher-disposition>',
+        "",
+        "---",
+        "",
+        "For each event, decide how to handle it and include a disposition block:",
+        "<watcher-disposition>",
         '{"event_id": "...", "disposition": "silent|notify|escalate", "action": "what you did", "title": "notification title", "body": "notification body"}',
-        '</watcher-disposition>',
-        '',
-        'You may include multiple disposition blocks, one per event.',
-      ].join('\n');
+        "</watcher-disposition>",
+        "",
+        "You may include multiple disposition blocks, one per event.",
+      ].join("\n");
 
       await processMessage(conversationId, message);
 
@@ -209,20 +229,27 @@ export async function runWatchersOnce(
       // tools to notify/escalate as needed.
       for (const event of pendingEvents) {
         // Default to silent if we can't parse the LLM response
-        updateEventDisposition(event.id, 'silent', 'Processed by LLM');
+        updateEventDisposition(event.id, "silent", "Processed by LLM");
       }
 
       processed++;
     } catch (err) {
-      log.warn({ err, watcherId: watcher.id }, 'Failed to process watcher events');
+      log.warn(
+        { err, watcherId: watcher.id },
+        "Failed to process watcher events",
+      );
       for (const event of pendingEvents) {
-        updateEventDisposition(event.id, 'error', err instanceof Error ? err.message : String(err));
+        updateEventDisposition(
+          event.id,
+          "error",
+          err instanceof Error ? err.message : String(err),
+        );
       }
     }
   }
 
   if (processed > 0) {
-    log.info({ processed }, 'Watcher tick complete');
+    log.info({ processed }, "Watcher tick complete");
   }
   return processed;
 }

package/src/watcher/provider-registry.ts

@@ -1,4 +1,4 @@
-import type { WatcherProvider } from './provider-types.js';
+import type { WatcherProvider } from "./provider-types.js";
 
 const providers = new Map<string, WatcherProvider>();
 

package/src/watcher/providers/github.ts

@@ -10,14 +10,18 @@
  * `notifications` scope (classic) or Notification read permission (fine-grained).
  */
 
-import { withValidToken } from '../../security/token-manager.js';
-import { getLogger } from '../../util/logger.js';
-import { truncate } from '../../util/truncate.js';
-import type { FetchResult,WatcherItem, WatcherProvider } from '../provider-types.js';
+import { withValidToken } from "../../security/token-manager.js";
+import { getLogger } from "../../util/logger.js";
+import { truncate } from "../../util/truncate.js";
+import type {
+  FetchResult,
+  WatcherItem,
+  WatcherProvider,
+} from "../provider-types.js";
 
-const log = getLogger('watcher:github');
+const log = getLogger("watcher:github");
 
-const GITHUB_API_BASE = 'https://api.github.com';
+const GITHUB_API_BASE = "https://api.github.com";
 
 // ── API types ──────────────────────────────────────────────────────────────────
 
@@ -30,7 +34,7 @@ interface GitHubNotification {
     title: string;
     url: string | null;
     latest_comment_url: string | null;
-    type: 'Issue' | 'PullRequest' | 'Release' | 'Commit' | string;
+    type: "Issue" | "PullRequest" | "Release" | "Commit" | string;
   };
   repository: {
     full_name: string;
@@ -42,11 +46,14 @@ interface GitHubNotification {
 
 /** Map a GitHub notification reason to a watcher event type. */
 function reasonToEventType(reason: string, subjectType: string): string {
-  if (reason === 'review_requested') return 'github_review_requested';
-  if (reason === 'assign') return subjectType === 'Issue' ? 'github_issue_assigned' : 'github_pr_assigned';
-  if (reason === 'mention') return 'github_mention';
-  if (subjectType === 'PullRequest') return 'github_pr_activity';
-  return 'github_notification';
+  if (reason === "review_requested") return "github_review_requested";
+  if (reason === "assign")
+    return subjectType === "Issue"
+      ? "github_issue_assigned"
+      : "github_pr_assigned";
+  if (reason === "mention") return "github_mention";
+  if (subjectType === "PullRequest") return "github_pr_activity";
+  return "github_notification";
 }
 
 function notificationToItem(n: GitHubNotification): WatcherItem {
@@ -80,22 +87,22 @@ async function fetchNotificationsPage(
   page: number,
 ): Promise<{ items: GitHubNotification[]; hasMore: boolean }> {
   const params = new URLSearchParams({
-    all: 'false', // only unread
+    all: "false", // only unread
     since,
-    per_page: '50',
+    per_page: "50",
     page: String(page),
   });
 
   const resp = await fetch(`${GITHUB_API_BASE}/notifications?${params}`, {
     headers: {
       Authorization: `Bearer ${token}`,
-      Accept: 'application/vnd.github+json',
-      'X-GitHub-Api-Version': '2022-11-28',
+      Accept: "application/vnd.github+json",
+      "X-GitHub-Api-Version": "2022-11-28",
     },
   });
 
   if (!resp.ok) {
-    const body = await resp.text().catch(() => '');
+    const body = await resp.text().catch(() => "");
     throw new Error(`GitHub Notifications API ${resp.status}: ${body}`);
   }
 
@@ -108,9 +115,9 @@ async function fetchNotificationsPage(
 // ── Provider ───────────────────────────────────────────────────────────────────
 
 export const githubProvider: WatcherProvider = {
-  id: 'github',
-  displayName: 'GitHub',
-  requiredCredentialService: 'integration:github',
+  id: "github",
+  displayName: "GitHub",
+  requiredCredentialService: "integration:github",
 
   async getInitialWatermark(_credentialService: string): Promise<string> {
     // Start from "now" so we don't replay all existing notifications
@@ -129,12 +136,19 @@ export const githubProvider: WatcherProvider = {
       let page = 1;
 
       while (true) {
-        const { items: pageItems, hasMore } = await fetchNotificationsPage(token, since, page);
+        const { items: pageItems, hasMore } = await fetchNotificationsPage(
+          token,
+          since,
+          page,
+        );
 
         for (const n of pageItems) {
           // Only surface notifications for reasons that warrant attention
           const relevantReasons = new Set([
-            'assign', 'mention', 'review_requested', 'team_mention',
+            "assign",
+            "mention",
+            "review_requested",
+            "team_mention",
           ]);
           if (!relevantReasons.has(n.reason)) continue;
 
@@ -149,7 +163,10 @@ export const githubProvider: WatcherProvider = {
       // that arrive between poll cycles.
       const newWatermark = new Date().toISOString();
 
-      log.info({ count: items.length, watermark: newWatermark }, 'GitHub: fetched new notifications');
+      log.info(
+        { count: items.length, watermark: newWatermark },
+        "GitHub: fetched new notifications",
+      );
       return { items, watermark: newWatermark };
     });
   },