@vellumai/assistant 0.8.1 → 0.8.2

package/src/daemon/plugin-source-watcher.ts

@@ -0,0 +1,146 @@
+/**
+ * Filesystem watcher for the external plugins directory.
+ *
+ * Watches `<workspaceDir>/plugins/` recursively using fs.watch (FSEvents on
+ * macOS). When a plugin directory is created or modified, debounces per
+ * top-level directory name (= the plugin name) and dispatches to the
+ * watcher's internal change handler so the daemon can register or reload
+ * the plugin without a restart.
+ *
+ * Mirrors `app-source-watcher.ts` (same DebouncerMap shape, same start/stop
+ * lifecycle, same ensureStarted late-create hook), but exposes its lifecycle
+ * through a static singleton so tool side-effects can call
+ * `PluginSourceWatcher.getInstance().ensureStarted()` directly without an
+ * intermediate module-level injection.
+ */
+
+import { type FSWatcher, mkdirSync, watch } from "node:fs";
+
+import { DebouncerMap } from "../util/debounce.js";
+import { getLogger } from "../util/logger.js";
+import { getWorkspacePluginsDir } from "../util/platform.js";
+import { reregisterExternalPlugin } from "./external-plugins-bootstrap.js";
+
+const log = getLogger("plugin-source-watcher");
+
+const PLUGIN_SOURCE_DEBOUNCE_MS = 500;
+
+/**
+ * Extract the plugin's top-level directory name from a relative path within
+ * the plugins root. Returns null for a stray file directly in `plugins/`
+ * (not a plugin dir).
+ */
+function resolvePluginNameFromRelPath(relPath: string): string | null {
+  const slashIdx = relPath.indexOf("/");
+  if (slashIdx === -1) {
+    // Bare entry under plugins/ — fs.watch reports these when a new
+    // directory is first created. We treat the name as the plugin name and
+    // let the install path decide whether it's a real plugin.
+    return relPath.length > 0 ? relPath : null;
+  }
+  const dirName = relPath.slice(0, slashIdx);
+  return dirName.length > 0 ? dirName : null;
+}
+
+export class PluginSourceWatcher {
+  /**
+   * Process-wide singleton. Callers reach the watcher via
+   * {@link PluginSourceWatcher.getInstance} rather than instantiating
+   * directly so tool side-effects (`assistant plugins install`) can call
+   * `ensureStarted()` on the same watcher the daemon `start()`/`stop()`
+   * lifecycle owns, without threading an instance through a registered
+   * module-level callback.
+   */
+  private static singleton: PluginSourceWatcher | null = null;
+
+  static getInstance(): PluginSourceWatcher {
+    PluginSourceWatcher.singleton ??= new PluginSourceWatcher();
+    return PluginSourceWatcher.singleton;
+  }
+
+  /** Test-only — drops the singleton so the next `getInstance()` rebuilds. */
+  static resetForTests(): void {
+    PluginSourceWatcher.singleton?.stop();
+    PluginSourceWatcher.singleton = null;
+  }
+
+  private watcher: FSWatcher | null = null;
+  private started = false;
+  private debouncer = new DebouncerMap({
+    defaultDelayMs: PLUGIN_SOURCE_DEBOUNCE_MS,
+    maxEntries: 50,
+  });
+
+  start(): void {
+    this.started = true;
+    this.tryWatch();
+  }
+
+  /**
+   * Ensure the watcher is running. Idempotent — safe to call after a tool
+   * side-effect that may have just created the plugins directory.
+   * No-op if `start()` has not been called yet.
+   */
+  ensureStarted(): void {
+    if (!this.started || this.watcher) return;
+    this.tryWatch();
+  }
+
+  stop(): void {
+    this.started = false;
+    this.debouncer.cancelAll();
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+    }
+  }
+
+  private onChange(pluginName: string): Promise<void> {
+    return reregisterExternalPlugin(pluginName);
+  }
+
+  private tryWatch(): void {
+    if (this.watcher) return;
+
+    let pluginsDir: string;
+    try {
+      pluginsDir = getWorkspacePluginsDir();
+    } catch {
+      log.warn(
+        "Could not resolve plugins directory; plugin source watching disabled",
+      );
+      return;
+    }
+
+    try {
+      mkdirSync(pluginsDir, { recursive: true });
+    } catch (err) {
+      log.warn(
+        { err, pluginsDir },
+        "Could not create plugins directory; source watching disabled",
+      );
+      return;
+    }
+
+    try {
+      this.watcher = watch(
+        pluginsDir,
+        { recursive: true },
+        (_eventType, filename) => {
+          if (!filename) return;
+          const pluginName = resolvePluginNameFromRelPath(filename);
+          if (!pluginName) return;
+          this.debouncer.schedule(`plugin:${pluginName}`, () => {
+            void this.onChange(pluginName);
+          });
+        },
+      );
+      log.info({ pluginsDir }, "Plugin source watcher started");
+    } catch (err) {
+      log.warn(
+        { err },
+        "Failed to watch plugins directory; source watching disabled",
+      );
+    }
+  }
+}

package/src/daemon/process-message.ts

@@ -30,9 +30,13 @@ import {
 import { updateMetaFile } from "../memory/conversation-disk-view.js";
 import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
+import { publishConversationMessagesChanged } from "../runtime/sync/resource-sync-events.js";
 import { getLogger } from "../util/logger.js";
 import type { Conversation } from "./conversation.js";
-import { buildSlackMetaForPersistence } from "./conversation-messaging.js";
+import {
+  buildSlackMetaForPersistence,
+  serializePersistedUserMessageContent,
+} from "./conversation-messaging.js";
 import { formatCompactResult } from "./conversation-process.js";
 import { resolveChannelCapabilities } from "./conversation-runtime-assembly.js";
 import {
@@ -314,7 +318,11 @@ export async function processMessage(
     const persisted = await addMessage(
       conversationId,
       "user",
-      JSON.stringify(cleanMsg.content),
+      serializePersistedUserMessageContent(
+        content,
+        attachments,
+        options?.displayContent,
+      ),
       userMetaWithSlack,
     );
     conversation.getMessages().push(llmMsg);
@@ -368,6 +376,7 @@ export async function processMessage(
       serverChannelMeta,
     );
     conversation.getMessages().push(assistantMsg);
+    publishConversationMessagesChanged(conversationId);
     return { messageId: persisted.id };
   }
 
@@ -399,7 +408,11 @@ export async function processMessage(
     const persisted = await addMessage(
       conversationId,
       "user",
-      JSON.stringify(cleanMsg.content),
+      serializePersistedUserMessageContent(
+        content,
+        attachments,
+        options?.displayContent,
+      ),
       compactUserMeta,
     );
     conversation.getMessages().push(cleanMsg);
@@ -421,6 +434,7 @@ export async function processMessage(
       compactChannelMeta,
     );
     conversation.getMessages().push(assistantMsg);
+    publishConversationMessagesChanged(conversationId);
     return { messageId: persisted.id };
   }
 
@@ -435,7 +449,9 @@ export async function processMessage(
     attachments,
     requestId,
     persistMetadata,
+    options?.displayContent,
   );
+  publishConversationMessagesChanged(conversationId);
 
   if (options?.isInteractive === true) {
     conversation.updateClient(broadcastMessage, false);
@@ -499,7 +515,9 @@ export async function processMessageInBackground(
     attachments,
     requestId,
     persistMetadata,
+    options?.displayContent,
   );
+  publishConversationMessagesChanged(conversationId);
 
   if (options?.isInteractive === true) {
     conversation.updateClient(broadcastMessage, false);

package/src/daemon/server.ts

@@ -16,7 +16,9 @@ import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import { getSigningKeyFingerprint } from "../runtime/auth/token-service.js";
 import {
   publishAvatarChanged,
+  publishConfigChanged,
   publishIdentityChanged,
+  publishSoundsConfigUpdated,
 } from "../runtime/sync/resource-sync-events.js";
 import { updatePublishedAppDeployment } from "../services/published-app-updater.js";
 import { getSubagentManager } from "../subagent/index.js";
@@ -43,6 +45,8 @@ import { refreshSurfacesForApp } from "./conversation-surfaces.js";
 import { parseIdentityFields } from "./handlers/identity.js";
 import type { ConversationCreateOptions } from "./handlers/shared.js";
 import { setGlobalSkillIpcSender } from "./meet-host-supervisor.js";
+import { PluginSourceWatcher } from "./plugin-source-watcher.js";
+import { refreshSkillCapabilityMemories } from "./skill-memory-refresh.js";
 
 const log = getLogger("server");
 
@@ -68,6 +72,7 @@ export class DaemonServer {
   // Composed subsystems
   private configWatcher = getConfigWatcher();
   private appSourceWatcher = new AppSourceWatcher();
+  private pluginSourceWatcher = PluginSourceWatcher.getInstance();
   private cliIpc = new AssistantIpcServer();
   private skillIpc = new SkillIpcServer();
 
@@ -193,11 +198,11 @@ export class DaemonServer {
   }
 
   private broadcastConfigChanged(): void {
-    broadcastMessage({ type: "config_changed" });
+    publishConfigChanged();
   }
 
   private broadcastSoundsConfigUpdated(): void {
-    broadcastMessage({ type: "sounds_config_updated" });
+    publishSoundsConfigUpdated();
   }
 
   private broadcastAvatarUpdated(): void {
@@ -279,12 +284,15 @@ export class DaemonServer {
       () => this.broadcastSoundsConfigUpdated(),
       () => this.broadcastAvatarUpdated(),
       () => this.broadcastConfigChanged(),
+      () => refreshSkillCapabilityMemories(getConfig()),
     );
 
     this.syncIdentityToPlatform();
 
     this.appSourceWatcher.start((appId) => this.handleAppSourceChange(appId));
 
+    this.pluginSourceWatcher.start();
+
     // Broadcast contacts_changed to all clients when any contact mutation occurs.
     this.unsubscribeContactChange = onContactChange(() => {
       broadcastMessage({ type: "contacts_changed" });
@@ -299,6 +307,7 @@ export class DaemonServer {
     this.evictor.stop();
     this.configWatcher.stop();
     this.appSourceWatcher.stop();
+    this.pluginSourceWatcher.stop();
     this.cliIpc.stop();
     this.skillIpc.stop();
     if (this.unsubscribeContactChange) {

package/src/daemon/skill-memory-refresh.ts

@@ -0,0 +1,29 @@
+import { getConfig } from "../config/loader.js";
+import type { AssistantConfig } from "../config/schema.js";
+import {
+  seedSkillGraphNodes,
+  seedUninstalledCatalogSkillMemories,
+} from "../memory/graph/capability-seed.js";
+import { getLogger } from "../util/logger.js";
+import { maybeSeedMemoryV2Skills } from "./memory-v2-startup.js";
+
+const log = getLogger("skill-memory-refresh");
+
+export function refreshSkillCapabilityMemories(
+  config: AssistantConfig = getConfig(),
+): void {
+  seedSkillGraphNodes();
+  maybeSeedMemoryV2Skills(config);
+  void seedUninstalledCatalogSkillMemories()
+    .then(() => {
+      // Re-run after the async catalog fetch populates the cache so stale
+      // installed-skill nodes can be pruned without deleting catalog-only nodes.
+      seedSkillGraphNodes();
+    })
+    .catch((err) =>
+      log.warn(
+        { err },
+        "Uninstalled catalog skill memory seeding failed — continuing",
+      ),
+    );
+}

package/src/documents/document-store.ts

@@ -5,11 +5,26 @@
  * background jobs (e.g. proactive artifact generation) can persist documents
  * without going through the HTTP layer.
  */
-import { rawGet, rawRun } from "../memory/raw-query.js";
+import { rawAll, rawGet, rawRun } from "../memory/raw-query.js";
 import { getLogger } from "../util/logger.js";
 
 const log = getLogger("document-store");
 
+// ---------------------------------------------------------------------------
+// Shared types
+// ---------------------------------------------------------------------------
+
+/** A document record with camelCase field names, mapped from the SQLite row. */
+export interface DocumentRecord {
+  surfaceId: string;
+  conversationId: string;
+  title: string;
+  content: string;
+  wordCount: number;
+  createdAt: number;
+  updatedAt: number;
+}
+
 // ---------------------------------------------------------------------------
 // Junction table helper
 // ---------------------------------------------------------------------------
@@ -27,6 +42,204 @@ export function addDocumentConversation(
   );
 }
 
+// ---------------------------------------------------------------------------
+// Shared query helpers
+// ---------------------------------------------------------------------------
+
+interface DocumentRow {
+  surface_id: string;
+  conversation_id: string;
+  title: string;
+  content: string;
+  word_count: number;
+  created_at: number;
+  updated_at: number;
+}
+
+type DocumentListRow = Omit<DocumentRow, "content">;
+
+function escapeSqlLikePattern(value: string): string {
+  return value.replace(/[\\%_]/g, "\\$&");
+}
+
+function mapRowToRecord(row: DocumentRow): DocumentRecord {
+  return {
+    surfaceId: row.surface_id,
+    conversationId: row.conversation_id,
+    title: row.title,
+    content: row.content,
+    wordCount: row.word_count,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+  };
+}
+
+/** Look up a single document by surface ID. Returns `null` when not found. */
+export function getDocumentById(surfaceId: string): DocumentRecord | null {
+  try {
+    const row = rawGet<DocumentRow>(
+      /*sql*/ `SELECT surface_id, conversation_id, title, content, word_count, created_at, updated_at
+       FROM documents
+       WHERE surface_id = ?`,
+      surfaceId,
+    );
+
+    if (!row) {
+      log.info({ surfaceId }, "Document not found");
+      return null;
+    }
+
+    log.info({ surfaceId }, "Loaded document");
+    return mapRowToRecord(row);
+  } catch (error) {
+    log.error({ err: error, surfaceId }, "Load error");
+    return null;
+  }
+}
+
+/** Return true when a document is associated with a conversation. */
+export function isDocumentAssociatedWithConversation(
+  surfaceId: string,
+  conversationId: string,
+): boolean {
+  try {
+    const row = rawGet<{ found: number }>(
+      /*sql*/ `
+      SELECT 1 AS found
+      FROM document_conversations
+      WHERE surface_id = ? AND conversation_id = ?
+      LIMIT 1
+      `,
+      surfaceId,
+      conversationId,
+    );
+    return row != null;
+  } catch (error) {
+    log.error(
+      { err: error, surfaceId, conversationId },
+      "Document association check error",
+    );
+    return false;
+  }
+}
+
+/**
+ * List documents for a given conversation (via the junction table).
+ * Returns an empty array when the conversation has no documents or on error.
+ */
+export function getDocumentsForConversation(
+  conversationId: string,
+): Omit<DocumentRecord, "content">[] {
+  try {
+    const rows = rawAll<DocumentListRow>(
+      /*sql*/ `
+      SELECT d.surface_id, dc.conversation_id AS conversation_id,
+             d.title, d.word_count, d.created_at, d.updated_at
+      FROM documents d
+      INNER JOIN document_conversations dc ON d.surface_id = dc.surface_id
+      WHERE dc.conversation_id = ?
+      ORDER BY d.updated_at DESC
+      `,
+      conversationId,
+    );
+
+    log.info(
+      { conversationId, count: rows.length },
+      "Listed documents for conversation",
+    );
+    return rows.map((row) => ({
+      surfaceId: row.surface_id,
+      conversationId: row.conversation_id,
+      title: row.title,
+      wordCount: row.word_count,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+    }));
+  } catch (error) {
+    log.error({ err: error, conversationId }, "List error");
+    return [];
+  }
+}
+
+/**
+ * Search documents by title substring (case-insensitive).
+ * When `conversationId` is supplied, only documents associated with that
+ * conversation are returned.
+ * Returns documents ordered by most recently updated.
+ */
+export function searchDocumentsByTitle(
+  query: string,
+  options: { conversationId?: string } = {},
+): Omit<DocumentRecord, "content">[] {
+  try {
+    const pattern = `%${escapeSqlLikePattern(query)}%`;
+    const rows = options.conversationId
+      ? rawAll<DocumentListRow>(
+          /*sql*/ `
+          SELECT d.surface_id, dc.conversation_id AS conversation_id,
+                 d.title, d.word_count, d.created_at, d.updated_at
+          FROM documents d
+          INNER JOIN document_conversations dc ON d.surface_id = dc.surface_id
+          WHERE dc.conversation_id = ?
+            AND d.title COLLATE NOCASE LIKE ? ESCAPE '\\'
+          ORDER BY d.updated_at DESC
+          LIMIT 20
+          `,
+          options.conversationId,
+          pattern,
+        )
+      : rawAll<DocumentListRow>(
+          /*sql*/ `
+          SELECT surface_id, conversation_id, title, word_count, created_at, updated_at
+          FROM documents
+          WHERE title COLLATE NOCASE LIKE ? ESCAPE '\\'
+          ORDER BY updated_at DESC
+          LIMIT 20
+          `,
+          pattern,
+        );
+
+    log.info(
+      { query, conversationId: options.conversationId, count: rows.length },
+      "Searched documents by title",
+    );
+    return rows.map((row) => ({
+      surfaceId: row.surface_id,
+      conversationId: row.conversation_id,
+      title: row.title,
+      wordCount: row.word_count,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+    }));
+  } catch (error) {
+    log.error({ err: error, query }, "Search error");
+    return [];
+  }
+}
+
+/**
+ * Delete a document and its conversation associations.
+ * Returns `true` if the document existed and was deleted, `false` otherwise.
+ */
+export function deleteDocument(surfaceId: string): boolean {
+  try {
+    const changes = rawRun(
+      /*sql*/ `DELETE FROM documents WHERE surface_id = ?`,
+      surfaceId,
+    );
+    rawRun(
+      /*sql*/ `DELETE FROM document_conversations WHERE surface_id = ?`,
+      surfaceId,
+    );
+    const existed = changes > 0;
+    log.info({ surfaceId, existed }, "Deleted document");
+    return existed;
+  } catch (error) {
+    log.error({ err: error, surfaceId }, "Delete error");
+    return false;
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Document persistence
 // ---------------------------------------------------------------------------
@@ -89,7 +302,7 @@ export function updateDocumentContent(
   surfaceId: string,
   markdown: string,
   mode: string,
-): void {
+): { success: true } | { success: false; error: string } {
   try {
     const existing = rawGet<{ content: string }>(
       /*sql*/ `SELECT content FROM documents WHERE surface_id = ?`,
@@ -97,7 +310,7 @@ export function updateDocumentContent(
     );
     if (!existing) {
       log.info({ surfaceId }, "No persisted document to update");
-      return;
+      return { success: false, error: "Document not found" };
     }
     const sep = mode === "append" && existing.content.length > 0 ? "\n\n" : "";
     const newContent =
@@ -113,7 +326,12 @@ export function updateDocumentContent(
       surfaceId,
     );
     log.info({ surfaceId, mode }, "Updated document content");
+    return { success: true };
   } catch (error) {
     log.error({ err: error, surfaceId }, "Document content update error");
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error",
+    };
   }
 }

package/src/embedded/plugin-api.ts

@@ -0,0 +1,40 @@
+/**
+ * Embedded handle for `@vellumai/plugin-api`.
+ *
+ * Standard `import * as pluginApi from "../plugin-api/index.ts"` lets Bun's
+ * normal bundler walk the plugin-api module graph at build time — relative
+ * imports inside plugin-api (`./types.js`, future runtime siblings) are
+ * inlined naturally, with no separate build step. In `bun --compile`, this
+ * means plugin-api ships as part of the assistant binary's regular code
+ * graph; in JIT/Docker, it loads from source.
+ *
+ * The loaded namespace is then installed on `globalThis` under a versioned
+ * symbol. The boot-time shim writer (`ensurePluginApiShim`) enumerates
+ * {@link PLUGIN_API_EXPORTS} and generates a tiny ESM module at
+ * `<workspaceDir>/node_modules/@vellumai/plugin-api/index.js` that
+ * re-binds each runtime export from `globalThis`. User plugins that
+ * `import { ... } from "@vellumai/plugin-api"` walk up to that shim and
+ * pick up the bindings.
+ *
+ * Type-only exports erase before this module loads, so `Object.keys`
+ * sees only runtime exports. That's correct — types are a dev-time
+ * concern, resolved against plugin-api source via tsconfig path-mapping
+ * (or, post-PR-5, against a generated `.d.ts` next to the runtime
+ * shim).
+ */
+
+import * as pluginApi from "../plugin-api/index.js";
+
+/** Symbol key under which the plugin-api namespace is published on globalThis. */
+export const PLUGIN_API_REGISTRY_KEY = Symbol.for("vellum.plugin-api.v1");
+
+// Install on globalThis once at module-load time. The shim writer reads
+// `PLUGIN_API_EXPORTS` to know which bindings to re-export; the shim's
+// generated body then reads `globalThis[PLUGIN_API_REGISTRY_KEY]` to grab
+// the live module namespace.
+(globalThis as Record<symbol, unknown>)[PLUGIN_API_REGISTRY_KEY] = pluginApi;
+
+/** Names of the runtime exports the workspace shim should re-bind. */
+export const PLUGIN_API_EXPORTS: readonly string[] = Object.freeze(
+  Object.keys(pluginApi),
+);