@vellumai/assistant 0.6.5 → 0.6.6

package/src/ipc/__tests__/socket-path.test.ts

@@ -1,67 +1,28 @@
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { describe, expect, test } from "bun:test";
 
 import { resolveIpcSocketPath } from "../socket-path.js";
 
-const LONG_WORKSPACE_DIR =
-  "/Users/noaflaherty/.local/share/vellum-dev/assistants/vellum-safe-dace-8hrt6e/.vellum/workspace";
-
-let savedWorkspaceDir: string | undefined;
-let savedBaseDataDir: string | undefined;
-
-beforeEach(() => {
-  savedWorkspaceDir = process.env.VELLUM_WORKSPACE_DIR;
-  savedBaseDataDir = process.env.BASE_DATA_DIR;
-});
-
-afterEach(() => {
-  if (savedWorkspaceDir === undefined) {
-    delete process.env.VELLUM_WORKSPACE_DIR;
-  } else {
-    process.env.VELLUM_WORKSPACE_DIR = savedWorkspaceDir;
-  }
-  if (savedBaseDataDir === undefined) {
-    delete process.env.BASE_DATA_DIR;
-  } else {
-    process.env.BASE_DATA_DIR = savedBaseDataDir;
-  }
-});
+const LONG_BASE_DIR =
+  "/Users/alice-johnson/.local/share/vellum-dev/assistants/vellum-safe-dace-8hrt6e/.vellum/workspace";
 
 describe("resolveIpcSocketPath", () => {
-  test("uses workspace path when it is within the platform limit", () => {
-    process.env.VELLUM_WORKSPACE_DIR = "/tmp/vellum-workspace-test";
-    delete process.env.BASE_DATA_DIR;
-
-    const resolved = resolveIpcSocketPath("assistant-cli.sock");
-
-    expect(resolved.source).toBe("workspace");
-    expect(resolved.path).toBe("/tmp/vellum-workspace-test/assistant-cli.sock");
-    expect(Buffer.byteLength(resolved.path, "utf8")).toBeLessThanOrEqual(
-      resolved.maxPathBytes,
+  test("uses protected dir path when it is within the platform limit", () => {
+    const resolved = resolveIpcSocketPath(
+      "assistant-cli.sock",
+      "/tmp/vellum-test",
     );
-  });
-
-  test("falls back to BASE_DATA_DIR/ipc when workspace path is too long", () => {
-    process.env.VELLUM_WORKSPACE_DIR = LONG_WORKSPACE_DIR;
-    process.env.BASE_DATA_DIR = "/tmp/vellum-instance-test";
 
-    const resolved = resolveIpcSocketPath("assistant-cli.sock");
-
-    expect(resolved.source).toBe("base-data-dir");
-    expect(resolved.path).toBe(
-      "/tmp/vellum-instance-test/ipc/assistant-cli.sock",
-    );
+    expect(resolved.source).toBe("protected");
+    expect(resolved.path).toBe("/tmp/vellum-test/assistant-cli.sock");
     expect(Buffer.byteLength(resolved.path, "utf8")).toBeLessThanOrEqual(
       resolved.maxPathBytes,
     );
   });
 
-  test("falls back to tmpdir hash path when workspace path is too long and BASE_DATA_DIR is absent", () => {
-    process.env.VELLUM_WORKSPACE_DIR = LONG_WORKSPACE_DIR;
-    delete process.env.BASE_DATA_DIR;
-
-    const resolved = resolveIpcSocketPath("assistant-cli.sock");
+  test("falls back to tmpdir hash path when preferred path is too long", () => {
+    const resolved = resolveIpcSocketPath("assistant-cli.sock", LONG_BASE_DIR);
 
     expect(resolved.source).toBe("tmp-hash");
     expect(resolved.path.startsWith(join(tmpdir(), "vellum-ipc"))).toBe(true);

package/src/ipc/cli-client.ts

@@ -5,7 +5,7 @@
  * Returns a typed result object so callers can distinguish success
  * from connection failures and method errors.
  *
- * The preferred socket path is `{workspaceDir}/assistant-cli.sock`, with a
+ * The preferred socket path is `{protectedDir}/assistant-cli.sock`, with a
  * deterministic fallback for long AF_UNIX paths.
  */
 

package/src/ipc/cli-server.ts

@@ -10,7 +10,7 @@
  * - Request:  { "id": string, "method": string, "params"?: Record<string, unknown> }
  * - Response: { "id": string, "result"?: unknown, "error"?: string }
  *
- * The preferred socket path is `{workspaceDir}/assistant-cli.sock`. On
+ * The preferred socket path is `{protectedDir}/assistant-cli.sock`. On
  * platforms with strict AF_UNIX path limits (notably macOS), the server falls
  * back to a shorter deterministic path so CLI commands can still connect.
  */
@@ -64,11 +64,11 @@ export class CliIpcServer {
   constructor() {
     const socketResolution = resolveIpcSocketPath("assistant-cli.sock");
     this.socketPath = socketResolution.path;
-    if (socketResolution.source !== "workspace") {
+    if (socketResolution.source !== "protected") {
       log.warn(
         {
           source: socketResolution.source,
-          workspacePath: socketResolution.workspacePath,
+          preferredPath: socketResolution.preferredPath,
           resolvedPath: socketResolution.path,
           maxPathBytes: socketResolution.maxPathBytes,
         },

package/src/ipc/gateway-client.ts

@@ -12,6 +12,7 @@
 import { connect, type Socket } from "node:net";
 
 import { getLogger } from "../util/logger.js";
+import { getWorkspaceDir } from "../util/platform.js";
 import { resolveIpcSocketPath } from "./socket-path.js";
 
 const log = getLogger("gateway-ipc-client");
@@ -176,5 +177,7 @@ export async function ipcGetFeatureFlags(): Promise<Record<string, boolean>> {
 // ---------------------------------------------------------------------------
 
 function getGatewaySocketPath(): string {
-  return resolveIpcSocketPath("gateway.sock").path;
+  // The gateway server binds its socket under the workspace directory,
+  // so the client must resolve with getWorkspaceDir() to match.
+  return resolveIpcSocketPath("gateway.sock", getWorkspaceDir()).path;
 }

package/src/ipc/routes/browser-context.ts

@@ -20,6 +20,8 @@ export interface BrowserIpcContextResolution {
   trustClass: TrustClass;
   hostBrowserProxy?: HostBrowserProxy;
   transportInterface?: InterfaceId;
+  /** True when the browser proxy sender is registry-routed (extension-backed). */
+  hostBrowserRegistryRouted?: boolean;
 }
 
 export type BrowserIpcContextResolver = (

package/src/ipc/routes/browser.ts

@@ -82,6 +82,7 @@ export const browserExecuteRoute: IpcRoute = {
         trustClass: resolvedContext.trustClass,
         hostBrowserProxy: resolvedContext.hostBrowserProxy,
         transportInterface: resolvedContext.transportInterface,
+        hostBrowserRegistryRouted: resolvedContext.hostBrowserRegistryRouted,
       },
     );
 

package/src/ipc/routes/get-contact.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+
+import { getContact } from "../../contacts/contact-store.js";
+import type { IpcRoute } from "../cli-server.js";
+
+const GetContactParams = z.object({
+  id: z.string().min(1),
+});
+
+export const getContactRoute: IpcRoute = {
+  method: "get_contact",
+  handler: (params) => {
+    const { id } = GetContactParams.parse(params);
+    return getContact(id) ?? null;
+  },
+};

package/src/ipc/routes/index.ts

@@ -2,9 +2,16 @@ import type { IpcRoute } from "../cli-server.js";
 import { attachmentRoutes } from "./attachment.js";
 import { browserExecuteRoute } from "./browser.js";
 import { cacheRoutes } from "./cache.js";
+import { getContactRoute } from "./get-contact.js";
+import { listClientsRoute } from "./list-clients.js";
+import { mergeContactsRoute } from "./merge-contacts.js";
+import { notificationRoutes } from "./notification.js";
+import { renameConversationRoute } from "./rename-conversation.js";
+import { searchContactsRoute } from "./search-contacts.js";
 import { taskTemplateRoutes } from "./task.js";
 import { taskQueueRoutes } from "./task-queue.js";
 import { uiRequestRoute } from "./ui-request.js";
+import { upsertContactRoute } from "./upsert-contact.js";
 import { wakeConversationRoute } from "./wake-conversation.js";
 import { watcherRoutes } from "./watcher.js";
 
@@ -12,8 +19,15 @@ import { watcherRoutes } from "./watcher.js";
 export const cliIpcRoutes: IpcRoute[] = [
   ...attachmentRoutes,
   browserExecuteRoute,
+  getContactRoute,
+  listClientsRoute,
+  mergeContactsRoute,
+  renameConversationRoute,
+  searchContactsRoute,
   uiRequestRoute,
+  upsertContactRoute,
   wakeConversationRoute,
+  ...notificationRoutes,
   ...cacheRoutes,
   ...taskTemplateRoutes,
   ...taskQueueRoutes,

package/src/ipc/routes/list-clients.ts

@@ -0,0 +1,31 @@
+import { z } from "zod";
+
+import {
+  ClientRegistry,
+  getClientRegistry,
+} from "../../runtime/client-registry.js";
+import type { IpcRoute } from "../cli-server.js";
+
+const ListClientsParams = z
+  .object({
+    capability: z.string().optional(),
+  })
+  .optional();
+
+export const listClientsRoute: IpcRoute = {
+  method: "list_clients",
+  handler: async (params) => {
+    const parsed = ListClientsParams.parse(params);
+    const registry = getClientRegistry();
+
+    const entries = parsed?.capability
+      ? registry.listByCapability(
+          parsed.capability as Parameters<typeof registry.listByCapability>[0],
+        )
+      : registry.listAll();
+
+    return {
+      clients: entries.map((e) => ClientRegistry.toJSON(e)),
+    };
+  },
+};

package/src/ipc/routes/merge-contacts.ts

@@ -0,0 +1,17 @@
+import { z } from "zod";
+
+import { mergeContacts } from "../../contacts/contact-store.js";
+import type { IpcRoute } from "../cli-server.js";
+
+const MergeContactsParams = z.object({
+  keepId: z.string().min(1),
+  mergeId: z.string().min(1),
+});
+
+export const mergeContactsRoute: IpcRoute = {
+  method: "merge_contacts",
+  handler: (params) => {
+    const { keepId, mergeId } = MergeContactsParams.parse(params);
+    return mergeContacts(keepId, mergeId);
+  },
+};

package/src/ipc/routes/notification.ts

@@ -0,0 +1,133 @@
+/**
+ * IPC routes for the notification pipeline.
+ *
+ * Exposes emit_notification_signal and list_notification_events so CLI
+ * commands and external skill processes can drive the notification
+ * pipeline over the Unix domain socket IPC.
+ */
+
+import { z } from "zod";
+
+import { emitNotificationSignal } from "../../notifications/emit-signal.js";
+import { listEvents } from "../../notifications/events-store.js";
+import type { AttentionHints } from "../../notifications/signal.js";
+import type { IpcRoute } from "../cli-server.js";
+
+// ── Param schemas ─────────────────────────────────────────────────────
+
+const AttentionHintsSchema = z.object({
+  requiresAction: z.boolean(),
+  urgency: z.enum(["low", "medium", "high"]),
+  deadlineAt: z.number().optional(),
+  isAsyncBackground: z.boolean(),
+  visibleInSourceNow: z.boolean(),
+});
+
+const EmitSignalParams = z.object({
+  sourceEventName: z.string().min(1),
+  sourceChannel: z.enum([
+    "assistant_tool",
+    "vellum",
+    "phone",
+    "telegram",
+    "slack",
+    "scheduler",
+    "watcher",
+  ]),
+  sourceContextId: z.string().min(1),
+  attentionHints: AttentionHintsSchema,
+  contextPayload: z.record(z.string(), z.unknown()).optional(),
+  routingIntent: z
+    .enum(["single_channel", "multi_channel", "all_channels"])
+    .optional(),
+  dedupeKey: z.string().optional(),
+  throwOnError: z.boolean().optional(),
+});
+
+const ListNotificationEventsParams = z.object({
+  limit: z.number().int().positive().optional(),
+  sourceEventName: z.string().optional(),
+});
+
+// ── Handlers ──────────────────────────────────────────────────────────
+
+async function handleEmitSignal(params?: Record<string, unknown>): Promise<{
+  signalId: string;
+  dispatched: boolean;
+  deduplicated: boolean;
+  reason: string;
+}> {
+  const validated = EmitSignalParams.parse(params);
+  const result = await emitNotificationSignal({
+    sourceEventName: validated.sourceEventName,
+    sourceChannel: validated.sourceChannel,
+    sourceContextId: validated.sourceContextId,
+    attentionHints: validated.attentionHints as AttentionHints,
+    contextPayload: validated.contextPayload as Record<string, unknown>,
+    routingIntent: validated.routingIntent,
+    dedupeKey: validated.dedupeKey,
+    throwOnError: validated.throwOnError,
+  });
+  return {
+    signalId: result.signalId,
+    dispatched: result.dispatched,
+    deduplicated: result.deduplicated,
+    reason: result.reason,
+  };
+}
+
+function handleListEvents(params?: Record<string, unknown>): Array<{
+  id: string;
+  sourceEventName: string;
+  sourceChannel: string;
+  sourceContextId: string;
+  urgency: string;
+  dedupeKey: string | null;
+  createdAt: string;
+}> {
+  const validated = ListNotificationEventsParams.parse(params);
+  const rows = listEvents({
+    limit: validated.limit,
+    sourceEventName: validated.sourceEventName,
+  });
+  return rows.map((row) => {
+    let urgency = "unknown";
+    try {
+      const hints = JSON.parse(row.attentionHintsJson) as {
+        urgency?: string;
+      };
+      if (hints.urgency) {
+        urgency = hints.urgency;
+      }
+    } catch {
+      // Leave urgency as "unknown" if parsing fails.
+    }
+    return {
+      id: row.id,
+      sourceEventName: row.sourceEventName,
+      sourceChannel: row.sourceChannel,
+      sourceContextId: row.sourceContextId,
+      urgency,
+      dedupeKey: row.dedupeKey,
+      createdAt: new Date(row.createdAt).toISOString(),
+    };
+  });
+}
+
+// ── Route definitions ─────────────────────────────────────────────────
+
+export const emitNotificationSignalRoute: IpcRoute = {
+  method: "emit_notification_signal",
+  handler: handleEmitSignal,
+};
+
+export const listNotificationEventsRoute: IpcRoute = {
+  method: "list_notification_events",
+  handler: handleListEvents,
+};
+
+/** All notification IPC routes. */
+export const notificationRoutes: IpcRoute[] = [
+  emitNotificationSignalRoute,
+  listNotificationEventsRoute,
+];

package/src/ipc/routes/rename-conversation.ts

@@ -0,0 +1,59 @@
+import { z } from "zod";
+
+import { renameConversation } from "../../daemon/handlers/conversations.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 { getLogger } from "../../util/logger.js";
+import type { IpcRoute } from "../cli-server.js";
+
+const log = getLogger("ipc:rename-conversation");
+
+const RenameConversationParams = z.object({
+  conversationId: z.string().min(1),
+  title: z.string().min(1),
+});
+
+export const renameConversationRoute: IpcRoute = {
+  method: "rename_conversation",
+  handler: async (params) => {
+    const { conversationId, title } = RenameConversationParams.parse(params);
+    const success = renameConversation(conversationId, title);
+    if (!success) {
+      return { ok: false, error: `Conversation ${conversationId} not found` };
+    }
+
+    // Broadcast events so connected clients update in real time.
+    assistantEventHub
+      .publish(
+        buildAssistantEvent(
+          DAEMON_INTERNAL_ASSISTANT_ID,
+          {
+            type: "conversation_title_updated",
+            conversationId,
+            title,
+          },
+          conversationId,
+        ),
+      )
+      .catch((err) => {
+        log.warn({ err }, "Failed to publish conversation_title_updated");
+      });
+
+    assistantEventHub
+      .publish(
+        buildAssistantEvent(DAEMON_INTERNAL_ASSISTANT_ID, {
+          type: "conversation_list_invalidated",
+          reason: "renamed",
+        }),
+      )
+      .catch((err) => {
+        log.warn(
+          { err },
+          "Failed to publish conversation_list_invalidated for rename",
+        );
+      });
+
+    return { ok: true };
+  },
+};

package/src/ipc/routes/search-contacts.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+
+import { searchContacts } from "../../contacts/contact-store.js";
+import type { IpcRoute } from "../cli-server.js";
+
+const SearchContactsParams = z.object({
+  query: z.string().optional(),
+  channelAddress: z.string().optional(),
+  channelType: z.string().optional(),
+  limit: z.number().optional(),
+});
+
+export const searchContactsRoute: IpcRoute = {
+  method: "search_contacts",
+  handler: (params) => {
+    const parsed = SearchContactsParams.parse(params);
+    return searchContacts(parsed);
+  },
+};

package/src/ipc/routes/upsert-contact.ts

@@ -0,0 +1,25 @@
+import { z } from "zod";
+
+import { upsertContact } from "../../contacts/contact-store.js";
+import type { IpcRoute } from "../cli-server.js";
+
+const ChannelSchema = z.object({
+  type: z.string(),
+  address: z.string(),
+  isPrimary: z.boolean().optional(),
+});
+
+const UpsertContactParams = z.object({
+  id: z.string().optional(),
+  displayName: z.string().min(1),
+  notes: z.string().optional(),
+  channels: z.array(ChannelSchema).optional(),
+});
+
+export const upsertContactRoute: IpcRoute = {
+  method: "upsert_contact",
+  handler: (params) => {
+    const parsed = UpsertContactParams.parse(params);
+    return upsertContact(parsed);
+  },
+};

package/src/ipc/socket-path.ts

@@ -2,23 +2,18 @@ import { createHash } from "node:crypto";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
-import { getWorkspaceDir } from "../util/platform.js";
+import { getProtectedDir } from "../util/platform.js";
 
 const DARWIN_UNIX_SOCKET_MAX_PATH_BYTES = 103;
 const DEFAULT_UNIX_SOCKET_MAX_PATH_BYTES = 107;
 const IPC_TMP_DIR_NAME = "vellum-ipc";
-const IPC_BASE_DATA_DIR_NAME = "ipc";
 
-export type IpcSocketPathSource =
-  | "workspace"
-  | "base-data-dir"
-  | "tmp-hash"
-  | "tmp-short-hash";
+export type IpcSocketPathSource = "protected" | "tmp-hash" | "tmp-short-hash";
 
 export interface IpcSocketPathResolution {
   path: string;
   source: IpcSocketPathSource;
-  workspacePath: string;
+  preferredPath: string;
   maxPathBytes: number;
 }
 
@@ -32,18 +27,12 @@ function isPathWithinSocketLimit(path: string, maxPathBytes: number): boolean {
   return Buffer.byteLength(path, "utf8") <= maxPathBytes;
 }
 
-function buildBaseDataDirCandidate(socketFileName: string): string | null {
-  const baseDataDir = process.env.BASE_DATA_DIR?.trim();
-  if (!baseDataDir) return null;
-  return join(baseDataDir, IPC_BASE_DATA_DIR_NAME, socketFileName);
-}
-
 function buildTmpCandidate(
-  workspacePath: string,
+  preferredPath: string,
   socketFileName: string,
 ): { hashedPath: string; shortPath: string } {
   const hash = createHash("sha256")
-    .update(workspacePath)
+    .update(preferredPath)
     .digest("hex")
     .slice(0, 12);
   return {
@@ -54,39 +43,26 @@ function buildTmpCandidate(
 
 export function resolveIpcSocketPath(
   socketFileName: string,
-  workspaceDir: string = getWorkspaceDir(),
+  baseDir: string = getProtectedDir(),
 ): IpcSocketPathResolution {
   const maxPathBytes = getUnixSocketMaxPathBytes();
-  const workspacePath = join(workspaceDir, socketFileName);
-
-  if (isPathWithinSocketLimit(workspacePath, maxPathBytes)) {
-    return {
-      path: workspacePath,
-      source: "workspace",
-      workspacePath,
-      maxPathBytes,
-    };
-  }
+  const preferredPath = join(baseDir, socketFileName);
 
-  const baseDataDirCandidate = buildBaseDataDirCandidate(socketFileName);
-  if (
-    baseDataDirCandidate &&
-    isPathWithinSocketLimit(baseDataDirCandidate, maxPathBytes)
-  ) {
+  if (isPathWithinSocketLimit(preferredPath, maxPathBytes)) {
     return {
-      path: baseDataDirCandidate,
-      source: "base-data-dir",
-      workspacePath,
+      path: preferredPath,
+      source: "protected",
+      preferredPath,
       maxPathBytes,
     };
   }
 
-  const tmpCandidate = buildTmpCandidate(workspacePath, socketFileName);
+  const tmpCandidate = buildTmpCandidate(preferredPath, socketFileName);
   if (isPathWithinSocketLimit(tmpCandidate.hashedPath, maxPathBytes)) {
     return {
       path: tmpCandidate.hashedPath,
       source: "tmp-hash",
-      workspacePath,
+      preferredPath,
       maxPathBytes,
     };
   }
@@ -94,7 +70,7 @@ export function resolveIpcSocketPath(
   return {
     path: tmpCandidate.shortPath,
     source: "tmp-short-hash",
-    workspacePath,
+    preferredPath,
     maxPathBytes,
   };
 }