@vellumai/assistant 0.4.44 → 0.4.45

package/src/daemon/handlers/skills.ts

@@ -1,13 +1,14 @@
 import { existsSync, rmSync } from "node:fs";
 import { join } from "node:path";
 
+import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
 import {
   getConfig,
   invalidateConfigCache,
   loadRawConfig,
   saveRawConfig,
 } from "../../config/loader.js";
-import { resolveSkillStates } from "../../config/skill-state.js";
+import { resolveSkillStates, skillFlagKey } from "../../config/skill-state.js";
 import {
   ensureSkillIcon,
   loadSkillBySelector,
@@ -51,7 +52,6 @@ import type {
 } from "../message-protocol.js";
 import {
   CONFIG_RELOAD_DEBOUNCE_MS,
-  defineHandlers,
   ensureSkillEntry,
   type HandlerContext,
   log,
@@ -62,7 +62,7 @@ import {
 /**
  * Minimal context needed by the standalone skill business-logic functions.
  * HandlerContext satisfies this interface, but HTTP routes can also provide
- * a compatible object without coupling to IPC internals.
+ * a compatible object without coupling to handler internals.
  */
 export interface SkillOperationContext {
   debounceTimers: HandlerContext["debounceTimers"];
@@ -204,7 +204,7 @@ function heuristicDraft(body: string): {
 const LLM_DRAFT_TIMEOUT_MS = 15_000;
 
 // ─── Standalone business-logic functions ─────────────────────────────────────
-// These are consumed by both the IPC handlers below and the HTTP route layer.
+// These are consumed by both the handlers below and the HTTP route layer.
 
 /** Helper: suppress config reload, save, debounce, and update fingerprint. */
 function saveConfigWithSuppression(
@@ -318,7 +318,11 @@ export function disableSkill(
 
 export function configureSkill(
   skillId: string,
-  config: { env?: Record<string, string>; apiKey?: string; config?: Record<string, unknown> },
+  config: {
+    env?: Record<string, string>;
+    apiKey?: string;
+    config?: Record<string, unknown>;
+  },
   ctx: SkillOperationContext,
 ): { success: true } | { success: false; error: string } {
   try {
@@ -343,6 +347,20 @@ export async function installSkill(
   try {
     // Bundled skills are already available — no install needed
     const catalog = loadSkillCatalog();
+
+    // Feature flag gate: reject install if the skill's flag is disabled
+    const config = getConfig();
+    const flaggedSkill = catalog.find((s) => s.id === spec.slug);
+    if (flaggedSkill) {
+      const flagKey = skillFlagKey(flaggedSkill);
+      if (flagKey && !isAssistantFeatureFlagEnabled(flagKey, config)) {
+        return {
+          success: false,
+          error: `Skill "${spec.slug}" is currently unavailable (disabled by feature flag)`,
+        };
+      }
+    }
+
     const bundled = catalog.find(
       (s) => s.id === spec.slug && s.source === "bundled",
     );
@@ -484,7 +502,9 @@ export async function updateSkill(
 
 export async function checkSkillUpdates(
   _ctx: SkillOperationContext,
-): Promise<{ success: true; data: unknown } | { success: false; error: string }> {
+): Promise<
+  { success: true; data: unknown } | { success: false; error: string }
+> {
   try {
     const updates = await clawhubCheckUpdates();
     return { success: true, data: updates };
@@ -498,7 +518,9 @@ export async function checkSkillUpdates(
 export async function searchSkills(
   query: string,
   _ctx: SkillOperationContext,
-): Promise<{ success: true; data: unknown } | { success: false; error: string }> {
+): Promise<
+  { success: true; data: unknown } | { success: false; error: string }
+> {
   try {
     const result = await clawhubSearch(query);
     return { success: true, data: result };
@@ -742,11 +764,9 @@ export async function createSkill(
   }
 }
 
-// ─── IPC handlers (thin wrappers) ───────────────────────────────────────────
+// ─── HTTP handlers (thin wrappers) ──────────────────────────────────────────
 
-export function handleSkillsList(
-  ctx: HandlerContext,
-): void {
+export function handleSkillsList(ctx: HandlerContext): void {
   const skills = listSkills(ctx);
   ctx.send({ type: "skills_list_response", skills });
 }
@@ -923,19 +943,3 @@ export async function handleSkillsCreate(
     ...result,
   });
 }
-
-export const skillHandlers = defineHandlers({
-  skills_list: (_msg, ctx) => handleSkillsList(ctx),
-  skill_detail: handleSkillDetail,
-  skills_enable: handleSkillsEnable,
-  skills_disable: handleSkillsDisable,
-  skills_configure: handleSkillsConfigure,
-  skills_install: handleSkillsInstall,
-  skills_uninstall: handleSkillsUninstall,
-  skills_update: handleSkillsUpdate,
-  skills_check_updates: handleSkillsCheckUpdates,
-  skills_search: handleSkillsSearch,
-  skills_inspect: handleSkillsInspect,
-  skills_draft: handleSkillsDraft,
-  skills_create: handleSkillsCreate,
-});

package/src/daemon/host-bash-proxy.ts

@@ -0,0 +1,148 @@
+import { v4 as uuid } from "uuid";
+
+import { getConfig } from "../config/loader.js";
+import { formatShellOutput } from "../tools/shared/shell-output.js";
+import type { ToolExecutionResult } from "../tools/types.js";
+import { AssistantError, ErrorCode } from "../util/errors.js";
+import { getLogger } from "../util/logger.js";
+import type { ServerMessage } from "./message-protocol.js";
+
+const log = getLogger("host-bash-proxy");
+
+interface PendingRequest {
+  resolve: (result: ToolExecutionResult) => void;
+  reject: (err: Error) => void;
+  timer: ReturnType<typeof setTimeout>;
+  timeoutSec: number;
+}
+
+export class HostBashProxy {
+  private pending = new Map<string, PendingRequest>();
+  private sendToClient: (msg: ServerMessage) => void;
+  private onInternalResolve?: (requestId: string) => void;
+  private clientConnected = false;
+
+  constructor(
+    sendToClient: (msg: ServerMessage) => void,
+    onInternalResolve?: (requestId: string) => void,
+  ) {
+    this.sendToClient = sendToClient;
+    this.onInternalResolve = onInternalResolve;
+  }
+
+  updateSender(
+    sendToClient: (msg: ServerMessage) => void,
+    clientConnected: boolean,
+  ): void {
+    this.sendToClient = sendToClient;
+    this.clientConnected = clientConnected;
+  }
+
+  request(
+    input: { command: string; working_dir?: string; timeout_seconds?: number },
+    sessionId: string,
+    signal?: AbortSignal,
+  ): Promise<ToolExecutionResult> {
+    if (signal?.aborted) {
+      const result = formatShellOutput("", "Aborted", null, false, 0);
+      return Promise.resolve(result);
+    }
+
+    const requestId = uuid();
+
+    return new Promise<ToolExecutionResult>((resolve, reject) => {
+      const shellMaxTimeoutSec = getConfig().timeouts.shellMaxTimeoutSec;
+      const timeoutSec = input.timeout_seconds ?? shellMaxTimeoutSec;
+      // Proxy timeout: slightly after client-side timeout, but before executor's outer timeout
+      const proxyTimeoutSec = timeoutSec + 3;
+      const timer = setTimeout(() => {
+        this.pending.delete(requestId);
+        this.onInternalResolve?.(requestId);
+        log.warn(
+          { requestId, command: input.command },
+          "Host bash proxy request timed out",
+        );
+        resolve(
+          formatShellOutput(
+            "",
+            "Host bash proxy timed out waiting for client response",
+            null,
+            true,
+            timeoutSec,
+          ),
+        );
+      }, proxyTimeoutSec * 1000);
+
+      this.pending.set(requestId, { resolve, reject, timer, timeoutSec });
+
+      if (signal) {
+        const onAbort = () => {
+          if (this.pending.has(requestId)) {
+            clearTimeout(timer);
+            this.pending.delete(requestId);
+            this.onInternalResolve?.(requestId);
+            resolve(formatShellOutput("", "Aborted", null, false, 0));
+          }
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
+
+      this.sendToClient({
+        type: "host_bash_request",
+        requestId,
+        sessionId,
+        command: input.command,
+        working_dir: input.working_dir,
+        timeout_seconds: input.timeout_seconds,
+      } as ServerMessage);
+    });
+  }
+
+  resolve(
+    requestId: string,
+    response: {
+      stdout: string;
+      stderr: string;
+      exitCode: number | null;
+      timedOut: boolean;
+    },
+  ): void {
+    const entry = this.pending.get(requestId);
+    if (!entry) {
+      log.warn({ requestId }, "No pending host bash request for response");
+      return;
+    }
+    clearTimeout(entry.timer);
+    this.pending.delete(requestId);
+    const result = formatShellOutput(
+      response.stdout,
+      response.stderr,
+      response.exitCode,
+      response.timedOut,
+      entry.timeoutSec,
+    );
+    entry.resolve(result);
+  }
+
+  hasPendingRequest(requestId: string): boolean {
+    return this.pending.has(requestId);
+  }
+
+  isAvailable(): boolean {
+    return this.clientConnected;
+  }
+
+  dispose(): void {
+    for (const [requestId, entry] of this.pending) {
+      clearTimeout(entry.timer);
+      this.onInternalResolve?.(requestId);
+      entry.reject(
+        new AssistantError(
+          "Host bash proxy disposed",
+          ErrorCode.INTERNAL_ERROR,
+        ),
+      );
+    }
+    this.pending.clear();
+  }
+}

package/src/daemon/host-file-proxy.ts

@@ -0,0 +1,135 @@
+import { v4 as uuid } from "uuid";
+
+import type { ToolExecutionResult } from "../tools/types.js";
+import { AssistantError, ErrorCode } from "../util/errors.js";
+import { getLogger } from "../util/logger.js";
+import type { ServerMessage } from "./message-protocol.js";
+import type { HostFileRequest } from "./message-types/host-file.js";
+
+/** Distributive omit that preserves union variant fields. */
+type DistributiveOmit<T, K extends PropertyKey> = T extends unknown
+  ? Omit<T, K>
+  : never;
+
+/** Clean input type for callers — transport envelope fields are added by the proxy. */
+export type HostFileInput = DistributiveOmit<
+  HostFileRequest,
+  "type" | "requestId" | "sessionId"
+>;
+
+const log = getLogger("host-file-proxy");
+
+interface PendingRequest {
+  resolve: (result: ToolExecutionResult) => void;
+  reject: (err: Error) => void;
+  timer: ReturnType<typeof setTimeout>;
+}
+
+export class HostFileProxy {
+  private pending = new Map<string, PendingRequest>();
+  private sendToClient: (msg: ServerMessage) => void;
+  private onInternalResolve?: (requestId: string) => void;
+  private clientConnected = false;
+
+  constructor(
+    sendToClient: (msg: ServerMessage) => void,
+    onInternalResolve?: (requestId: string) => void,
+  ) {
+    this.sendToClient = sendToClient;
+    this.onInternalResolve = onInternalResolve;
+  }
+
+  updateSender(
+    sendToClient: (msg: ServerMessage) => void,
+    clientConnected: boolean,
+  ): void {
+    this.sendToClient = sendToClient;
+    this.clientConnected = clientConnected;
+  }
+
+  request(
+    input: HostFileInput,
+    sessionId: string,
+    signal?: AbortSignal,
+  ): Promise<ToolExecutionResult> {
+    if (signal?.aborted) {
+      return Promise.resolve({ content: "Aborted", isError: true });
+    }
+
+    const requestId = uuid();
+
+    return new Promise<ToolExecutionResult>((resolve, reject) => {
+      // File operations should be fast — 30 second timeout.
+      const timeoutSec = 30;
+      const timer = setTimeout(() => {
+        this.pending.delete(requestId);
+        this.onInternalResolve?.(requestId);
+        log.warn(
+          { requestId, operation: input.operation },
+          "Host file proxy request timed out",
+        );
+        resolve({
+          content: "Host file proxy timed out waiting for client response",
+          isError: true,
+        });
+      }, timeoutSec * 1000);
+
+      this.pending.set(requestId, { resolve, reject, timer });
+
+      if (signal) {
+        const onAbort = () => {
+          if (this.pending.has(requestId)) {
+            clearTimeout(timer);
+            this.pending.delete(requestId);
+            this.onInternalResolve?.(requestId);
+            resolve({ content: "Aborted", isError: true });
+          }
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
+
+      this.sendToClient({
+        ...input,
+        type: "host_file_request",
+        requestId,
+        sessionId,
+      } as ServerMessage);
+    });
+  }
+
+  resolve(
+    requestId: string,
+    response: { content: string; isError: boolean },
+  ): void {
+    const entry = this.pending.get(requestId);
+    if (!entry) {
+      log.warn({ requestId }, "No pending host file request for response");
+      return;
+    }
+    clearTimeout(entry.timer);
+    this.pending.delete(requestId);
+    entry.resolve({ content: response.content, isError: response.isError });
+  }
+
+  hasPendingRequest(requestId: string): boolean {
+    return this.pending.has(requestId);
+  }
+
+  isAvailable(): boolean {
+    return this.clientConnected;
+  }
+
+  dispose(): void {
+    for (const [requestId, entry] of this.pending) {
+      clearTimeout(entry.timer);
+      this.onInternalResolve?.(requestId);
+      entry.reject(
+        new AssistantError(
+          "Host file proxy disposed",
+          ErrorCode.INTERNAL_ERROR,
+        ),
+      );
+    }
+    this.pending.clear();
+  }
+}

package/src/daemon/lifecycle.ts

@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
 import { chmodSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 
@@ -30,6 +31,7 @@ import {
   getMessages,
 } from "../memory/conversation-crud.js";
 import { initializeDb } from "../memory/db.js";
+import { selectEmbeddingBackend } from "../memory/embedding-backend.js";
 import { startMemoryJobsWorker } from "../memory/jobs-worker.js";
 import { initQdrantClient } from "../memory/qdrant-client.js";
 import { QdrantManager } from "../memory/qdrant-manager.js";
@@ -43,10 +45,10 @@ import { syncUpdateBulletinOnStartup } from "../prompts/update-bulletin.js";
 import { buildAssistantEvent } from "../runtime/assistant-event.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
+import { mintCredentialPair } from "../runtime/auth/credential-service.js";
 import {
   initAuthSigningKey,
   loadOrCreateSigningKey,
-  mintCliEdgeToken,
   mintPairingBearerToken,
 } from "../runtime/auth/token-service.js";
 import { ensureVellumGuardianBinding } from "../runtime/guardian-vellum-migration.js";
@@ -77,7 +79,6 @@ import {
   createGuardianActionCopyGenerator,
   createGuardianFollowUpConversationGenerator,
 } from "./guardian-action-generators.js";
-import { initPairingHandlers } from "./handlers/pairing.js";
 import {
   cancelGeneration,
   clearAllSessions,
@@ -141,14 +142,6 @@ export async function runDaemon(): Promise<void> {
     const signingKey = loadOrCreateSigningKey();
     initAuthSigningKey(signingKey);
 
-    // Mint a CLI edge token (JWT) so the CLI can authenticate with the
-    // gateway. Written early so the CLI doesn't time out polling.
-    const httpTokenPath = join(getRootDir(), "http-token");
-    const bearerToken = mintCliEdgeToken();
-    writeFileSync(httpTokenPath, bearerToken, { mode: 0o600 });
-    chmodSync(httpTokenPath, 0o600);
-    log.info("Daemon startup: bearer token written");
-
     log.info("Daemon startup: migrations complete");
 
     seedInterfaceFiles();
@@ -168,9 +161,13 @@ export async function runDaemon(): Promise<void> {
     initializeDb();
     log.info("Daemon startup: DB initialized");
 
-    // Backfill vellum guardian binding for existing installations
+    // Ensure a vellum guardian binding exists and mint the CLI edge token
+    // as an actor token bound to the guardian principal.
+    let guardianPrincipalId: string | undefined;
     try {
-      ensureVellumGuardianBinding(DAEMON_INTERNAL_ASSISTANT_ID);
+      guardianPrincipalId = ensureVellumGuardianBinding(
+        DAEMON_INTERNAL_ASSISTANT_ID,
+      );
     } catch (err) {
       log.warn(
         { err },
@@ -178,6 +175,29 @@ export async function runDaemon(): Promise<void> {
       );
     }
 
+    if (guardianPrincipalId) {
+      const cliDeviceId = "daemon-cli";
+      const hashedDeviceId = createHash("sha256")
+        .update(cliDeviceId)
+        .digest("hex");
+      const credentials = mintCredentialPair({
+        platform: "cli",
+        deviceId: cliDeviceId,
+        guardianPrincipalId,
+        hashedDeviceId,
+      });
+
+      // DEPRECATED: The http-token file is deprecated. Readers will be
+      // migrated to use the credential store instead. This write is kept
+      // for backward compatibility until all consumers are updated.
+      const httpTokenPath = join(getRootDir(), "http-token");
+      writeFileSync(httpTokenPath, credentials.accessToken, { mode: 0o600 });
+      chmodSync(httpTokenPath, 0o600);
+      log.info("Daemon startup: CLI edge token written to credential store and http-token");
+    } else {
+      log.warn("No guardian principal available — CLI edge token not written");
+    }
+
     try {
       syncUpdateBulletinOnStartup();
     } catch (err) {
@@ -252,12 +272,17 @@ export async function runDaemon(): Promise<void> {
     const qdrantManager = new QdrantManager({ url: qdrantUrl });
     try {
       await qdrantManager.start();
+      const embeddingSelection = selectEmbeddingBackend(config);
+      const embeddingModel = embeddingSelection.backend
+        ? `${embeddingSelection.backend.provider}:${embeddingSelection.backend.model}`
+        : undefined;
       initQdrantClient({
         url: qdrantUrl,
         collection: config.memory.qdrant.collection,
         vectorSize: config.memory.qdrant.vectorSize,
         onDisk: config.memory.qdrant.onDisk,
         quantization: config.memory.qdrant.quantization,
+        embeddingModel,
       });
       log.info("Qdrant vector store initialized");
     } catch (err) {
@@ -293,11 +318,11 @@ export async function runDaemon(): Promise<void> {
             : undefined,
         );
       },
-      (reminder) => {
-        void emitNotificationSignal({
-          sourceEventName: "reminder.fired",
+      async (schedule) => {
+        await emitNotificationSignal({
+          sourceEventName: "schedule.notify",
           sourceChannel: "scheduler",
-          sourceSessionId: reminder.id,
+          sourceSessionId: schedule.id,
           attentionHints: {
             requiresAction: true,
             urgency: "high",
@@ -305,13 +330,14 @@ export async function runDaemon(): Promise<void> {
             visibleInSourceNow: false,
           },
           contextPayload: {
-            reminderId: reminder.id,
-            label: reminder.label,
-            message: reminder.message,
+            scheduleId: schedule.id,
+            label: schedule.label,
+            message: schedule.message,
           },
-          routingIntent: reminder.routingIntent,
-          routingHints: reminder.routingHints,
-          dedupeKey: `reminder:${reminder.id}`,
+          routingIntent: schedule.routingIntent,
+          routingHints: schedule.routingHints,
+          dedupeKey: `schedule:notify:${schedule.id}:${Date.now()}`,
+          throwOnError: true,
         });
       },
       (schedule) => {
@@ -384,7 +410,7 @@ export async function runDaemon(): Promise<void> {
     const hostname = getRuntimeHttpHost();
 
     // Mint a JWT bearer token for the pairing flow. This replaces the
-    // old static http-token that was removed — the pairing IPC handler
+    // old static http-token that was removed — the pairing handler
     // and HTTP auto-approve logic both guard on a non-empty bearer token.
     const pairingBearerToken = mintPairingBearerToken();
 
@@ -706,7 +732,6 @@ export async function runDaemon(): Promise<void> {
       runtimeHttp.setPairingBroadcast((msg) =>
         server.broadcast(msg as ServerMessage),
       );
-      initPairingHandlers(runtimeHttp.getPairingStore(), pairingBearerToken);
       initSlashPairingContext(runtimeHttp.getPairingStore());
       server.setHttpPort(httpPort);
       log.info(

package/src/daemon/mcp-reload-service.ts

@@ -0,0 +1,123 @@
+/**
+ * Shared MCP reload business logic.
+ *
+ * Used by the HTTP route (`runtime/routes/mcp-routes.ts`) so the reload
+ * behaviour is defined in exactly one place.
+ */
+
+import { getConfig, invalidateConfigCache } from "../config/loader.js";
+import { getMcpServerManager } from "../mcp/manager.js";
+import { createMcpToolsFromServer } from "../tools/mcp/mcp-tool-factory.js";
+import { registerMcpTools, unregisterAllMcpTools } from "../tools/registry.js";
+import { getLogger } from "../util/logger.js";
+
+const log = getLogger("mcp-reload-service");
+
+/** Per-server reload result. */
+export interface McpReloadServerResult {
+  id: string;
+  connected: boolean;
+  /** True when the server is explicitly disabled in config. */
+  disabled?: boolean;
+  toolCount: number;
+  tools: string[];
+}
+
+export interface McpReloadResult {
+  success: boolean;
+  serverCount?: number;
+  toolCount?: number;
+  servers?: McpReloadServerResult[];
+  error?: string;
+}
+
+let reloadInProgress: Promise<McpReloadResult> | null = null;
+
+/**
+ * Stop all MCP servers, reload configuration from disk, and restart
+ * servers with the updated config. Returns a summary of the reload.
+ *
+ * Concurrent calls are serialized — if a reload is already in progress
+ * the caller receives the same promise instead of starting a second one.
+ */
+export function reloadMcpServers(): Promise<McpReloadResult> {
+  if (reloadInProgress) {
+    log.info("MCP reload already in progress, awaiting existing operation");
+    return reloadInProgress;
+  }
+  reloadInProgress = doReload().finally(() => {
+    reloadInProgress = null;
+  });
+  return reloadInProgress;
+}
+
+async function doReload(): Promise<McpReloadResult> {
+  try {
+    const manager = getMcpServerManager();
+
+    // 1. Validate new config before tearing down existing servers.
+    //    If the config is broken we abort early, preserving the current
+    //    working MCP setup instead of leaving zero servers.
+    invalidateConfigCache();
+    const config = getConfig();
+
+    // 2. Stop existing MCP servers + unregister their tools
+    await manager.stop();
+    unregisterAllMcpTools();
+    const serverIds = config.mcp?.servers
+      ? Object.keys(config.mcp.servers)
+      : [];
+
+    // 3. Restart MCP servers
+    let serverCount = 0;
+    let toolCount = 0;
+    const servers: McpReloadServerResult[] = [];
+
+    if (config.mcp?.servers && Object.keys(config.mcp.servers).length > 0) {
+      const serverToolInfos = await manager.start(config.mcp);
+      for (const { serverId, serverConfig, tools } of serverToolInfos) {
+        const mcpTools = createMcpToolsFromServer(
+          tools,
+          serverId,
+          serverConfig,
+          manager,
+        );
+        const accepted = registerMcpTools(mcpTools);
+        const acceptedNames = accepted.map((t) => t.name);
+        toolCount += accepted.length;
+        servers.push({
+          id: serverId,
+          connected: true,
+          toolCount: accepted.length,
+          tools: acceptedNames,
+        });
+      }
+      // Include servers that were configured but failed to connect or are disabled
+      for (const id of serverIds) {
+        if (!servers.some((s) => s.id === id)) {
+          const serverConfig = config.mcp!.servers![id];
+          const isDisabled = serverConfig?.enabled === false;
+          servers.push({
+            id,
+            connected: false,
+            disabled: isDisabled || undefined,
+            toolCount: 0,
+            tools: [],
+          });
+        }
+      }
+      serverCount = servers.length;
+    }
+
+    // Sessions pick up new MCP tools automatically on their next turn
+    // via the dynamic resolver in createResolveToolsCallback — no need
+    // to evict sessions.
+
+    log.info({ serverCount, toolCount }, "MCP servers reloaded");
+    return { success: true, serverCount, toolCount, servers };
+  } catch (err) {
+    const error = err instanceof Error ? err.message : String(err);
+    log.error({ err }, "MCP reload failed");
+    return { success: false, error };
+  }
+}