@vellumai/assistant 0.6.3 → 0.6.4

package/src/ipc/gateway-client.ts

@@ -0,0 +1,180 @@
+/**
+ * Assistant-side IPC client for communicating with the gateway.
+ *
+ * Connects to the gateway's Unix domain socket and provides typed methods
+ * for reading gateway-owned data. Protocol: newline-delimited JSON
+ * (same as gateway/src/ipc/server.ts).
+ *
+ * The socket lives at `{workspaceDir}/gateway.sock` on the shared volume.
+ */
+
+import { connect, type Socket } from "node:net";
+import { join } from "node:path";
+
+import { getLogger } from "../util/logger.js";
+import { getWorkspaceDir } from "../util/platform.js";
+
+const log = getLogger("gateway-ipc-client");
+
+// ---------------------------------------------------------------------------
+// Types (mirror gateway/src/ipc/server.ts protocol)
+// ---------------------------------------------------------------------------
+
+type IpcRequest = {
+  id: string;
+  method: string;
+  params?: Record<string, unknown>;
+};
+
+type IpcResponse = {
+  id: string;
+  result?: unknown;
+  error?: string;
+};
+
+// ---------------------------------------------------------------------------
+// Client
+// ---------------------------------------------------------------------------
+
+const DEFAULT_CALL_TIMEOUT_MS = 5_000;
+const CONNECT_TIMEOUT_MS = 3_000;
+
+/**
+ * One-shot IPC helper: connect, call a method, disconnect.
+ *
+ * Designed for CLI and daemon startup where we need a single RPC call
+ * without leaving open handles. Returns `undefined` on any failure
+ * (socket not found, timeout, parse error) so callers can fall back.
+ */
+export async function ipcCall(
+  method: string,
+  params?: Record<string, unknown>,
+): Promise<unknown> {
+  const socketPath = getGatewaySocketPath();
+
+  return new Promise<unknown>((resolve) => {
+    let settled = false;
+    let callTimer: ReturnType<typeof setTimeout> | undefined;
+
+    const finish = (value: unknown) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(connectTimer);
+      if (callTimer) clearTimeout(callTimer);
+      socket.destroy();
+      resolve(value);
+    };
+
+    const connectTimer = setTimeout(() => {
+      log.warn(
+        { method, socketPath, timeoutMs: CONNECT_TIMEOUT_MS },
+        "IPC connect timed out",
+      );
+      finish(undefined);
+    }, CONNECT_TIMEOUT_MS);
+
+    const socket: Socket = connect(socketPath);
+    // Prevent the socket from keeping the process alive (important for
+    // one-shot CLI commands that must exit after the call completes).
+    socket.unref();
+
+    let buffer = "";
+    const reqId = "1";
+
+    socket.on("connect", () => {
+      clearTimeout(connectTimer);
+      const req: IpcRequest = { id: reqId, method, params };
+      socket.write(JSON.stringify(req) + "\n");
+
+      // Call timeout — if the gateway doesn't respond in time, give up.
+      // Keep this timer ref'd (not unref'd) so the process waits for the
+      // response or timeout before exiting — the socket itself is unref'd.
+      callTimer = setTimeout(() => {
+        log.warn(
+          { method, socketPath, timeoutMs: DEFAULT_CALL_TIMEOUT_MS },
+          "IPC call timed out waiting for response",
+        );
+        finish(undefined);
+      }, DEFAULT_CALL_TIMEOUT_MS);
+
+      socket.on("data", (chunk) => {
+        buffer += chunk.toString();
+        let newlineIdx: number;
+        while ((newlineIdx = buffer.indexOf("\n")) !== -1) {
+          const line = buffer.slice(0, newlineIdx).trim();
+          buffer = buffer.slice(newlineIdx + 1);
+          if (!line) continue;
+
+          try {
+            const msg = JSON.parse(line) as IpcResponse;
+            if (msg.id === reqId) {
+              if (msg.error) {
+                log.warn(
+                  { error: msg.error, method },
+                  "IPC call returned error",
+                );
+                finish(undefined);
+              } else {
+                finish(msg.result);
+              }
+              return;
+            }
+          } catch {
+            // Ignore malformed lines
+          }
+        }
+      });
+    });
+
+    socket.on("error", (err) => {
+      log.warn(
+        {
+          err,
+          code: (err as NodeJS.ErrnoException).code,
+          method,
+          socketPath,
+        },
+        "Gateway IPC socket error",
+      );
+      finish(undefined);
+    });
+
+    socket.on("close", () => {
+      if (!settled) {
+        log.warn(
+          { method, socketPath },
+          "Gateway IPC socket closed before response",
+        );
+      }
+      finish(undefined);
+    });
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Typed helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Fetch all merged feature flags from the gateway via IPC.
+ * Returns an empty record on any failure.
+ */
+export async function ipcGetFeatureFlags(): Promise<Record<string, boolean>> {
+  const result = await ipcCall("get_feature_flags");
+  if (result && typeof result === "object" && !Array.isArray(result)) {
+    const filtered: Record<string, boolean> = {};
+    for (const [k, v] of Object.entries(result as Record<string, unknown>)) {
+      if (typeof v === "boolean") filtered[k] = v;
+    }
+    return filtered;
+  }
+  return {};
+}
+
+// ---------------------------------------------------------------------------
+// Socket path
+// ---------------------------------------------------------------------------
+
+function getGatewaySocketPath(): string {
+  return join(getWorkspaceDir(), "gateway.sock");
+}

package/src/ipc/routes/index.ts

@@ -0,0 +1,5 @@
+import type { IpcRoute } from "../cli-server.js";
+import { wakeConversationRoute } from "./wake-conversation.js";
+
+/** All built-in CLI IPC routes. */
+export const cliIpcRoutes: IpcRoute[] = [wakeConversationRoute];

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

@@ -0,0 +1,19 @@
+import { z } from "zod";
+
+import { wakeAgentForOpportunity } from "../../runtime/agent-wake.js";
+import type { IpcRoute } from "../cli-server.js";
+
+const WakeConversationParams = z.object({
+  conversationId: z.string().min(1),
+  hint: z.string().min(1),
+  source: z.string().default("cli"),
+});
+
+export const wakeConversationRoute: IpcRoute = {
+  method: "wake_conversation",
+  handler: async (params) => {
+    const { conversationId, hint, source } =
+      WakeConversationParams.parse(params);
+    return wakeAgentForOpportunity({ conversationId, hint, source });
+  },
+};

package/src/memory/__tests__/auto-analysis-enqueue.test.ts

@@ -0,0 +1,356 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+// ---------------------------------------------------------------------------
+// Mock state — reset between tests.
+// ---------------------------------------------------------------------------
+
+let flagEnabled = true;
+let isAuto = false;
+let conversationType: "standard" | "private" = "standard";
+let configValue: { analysis?: { idleTimeoutMs?: number } } = {
+  analysis: { idleTimeoutMs: 600_000 },
+};
+let getConfigThrows = false;
+
+const enqueueCalls: Array<{
+  type: string;
+  payload: Record<string, unknown>;
+  runAfter?: number;
+}> = [];
+const debouncedCalls: Array<{
+  type: string;
+  payload: { conversationId: string; triggerGroup: "immediate" | "debounced" };
+  runAfter: number;
+}> = [];
+
+mock.module("../../config/loader.js", () => ({
+  getConfig: () => {
+    if (getConfigThrows) throw new Error("boom");
+    return configValue;
+  },
+}));
+
+mock.module("../../config/assistant-feature-flags.js", () => ({
+  isAssistantFeatureFlagEnabled: (_key: string, _config: unknown) =>
+    flagEnabled,
+}));
+
+mock.module("../auto-analysis-guard.js", () => ({
+  AUTO_ANALYSIS_SOURCE: "auto-analysis",
+  isAutoAnalysisConversation: (_conversationId: string) => isAuto,
+}));
+
+mock.module("../conversation-crud.js", () => ({
+  getConversationType: (_conversationId: string) => conversationType,
+}));
+
+mock.module("../jobs-store.js", () => ({
+  enqueueMemoryJob: (
+    type: string,
+    payload: Record<string, unknown>,
+    runAfter?: number,
+  ) => {
+    enqueueCalls.push({ type, payload, runAfter });
+    return "job-id";
+  },
+  upsertAutoAnalysisJob: (
+    payload: {
+      conversationId: string;
+      triggerGroup: "immediate" | "debounced";
+    },
+    runAfter: number,
+  ) => {
+    debouncedCalls.push({
+      type: "conversation_analyze",
+      payload,
+      runAfter,
+    });
+  },
+}));
+
+// Mirror production semantics from `isUntrustedTrustClass` in
+// actor-trust-resolver.ts: anything that isn't `guardian` is untrusted.
+// Keeping these in sync guards the compaction trust boundary — a drifting
+// mock would let regressions pass as false positives.
+mock.module("../../runtime/actor-trust-resolver.js", () => ({
+  isUntrustedTrustClass: (trustClass: string | undefined) =>
+    trustClass === "trusted_contact" ||
+    trustClass === "unknown" ||
+    trustClass === undefined,
+}));
+
+import {
+  enqueueAutoAnalysisIfEnabled,
+  enqueueAutoAnalysisOnCompaction,
+} from "../auto-analysis-enqueue.js";
+
+describe("enqueueAutoAnalysisIfEnabled", () => {
+  beforeEach(() => {
+    flagEnabled = true;
+    isAuto = false;
+    conversationType = "standard";
+    getConfigThrows = false;
+    configValue = { analysis: { idleTimeoutMs: 600_000 } };
+    enqueueCalls.length = 0;
+    debouncedCalls.length = 0;
+  });
+
+  test("flag off — no job is enqueued for any trigger", () => {
+    flagEnabled = false;
+
+    enqueueAutoAnalysisIfEnabled({ conversationId: "c1", trigger: "batch" });
+    enqueueAutoAnalysisIfEnabled({ conversationId: "c1", trigger: "idle" });
+    enqueueAutoAnalysisIfEnabled({
+      conversationId: "c1",
+      trigger: "lifecycle",
+    });
+
+    expect(enqueueCalls).toHaveLength(0);
+    expect(debouncedCalls).toHaveLength(0);
+  });
+
+  test("flag on, trigger = 'batch', normal source — upsertDebouncedJob called with runAfter ≈ now", () => {
+    const before = Date.now();
+
+    enqueueAutoAnalysisIfEnabled({ conversationId: "c1", trigger: "batch" });
+
+    const after = Date.now();
+
+    expect(debouncedCalls).toHaveLength(1);
+    expect(debouncedCalls[0]!.type).toBe("conversation_analyze");
+    expect(debouncedCalls[0]!.payload).toEqual({
+      conversationId: "c1",
+      triggerGroup: "immediate",
+    });
+    // "batch" fires immediately (no debounce), so runAfter ≈ now. The
+    // "immediate" triggerGroup keeps this row from coalescing with any
+    // "debounced" (idle/lifecycle) row — an idle enqueue cannot push
+    // this runAfter into the future.
+    expect(debouncedCalls[0]!.runAfter).toBeGreaterThanOrEqual(before);
+    expect(debouncedCalls[0]!.runAfter).toBeLessThanOrEqual(after);
+    expect(enqueueCalls).toHaveLength(0);
+  });
+
+  test("flag on, trigger = 'idle', normal source — upsertAutoAnalysisJob called with runAfter ≈ now + idleTimeoutMs", () => {
+    configValue = { analysis: { idleTimeoutMs: 600_000 } };
+    const before = Date.now();
+
+    enqueueAutoAnalysisIfEnabled({ conversationId: "c1", trigger: "idle" });
+
+    const after = Date.now();
+
+    expect(debouncedCalls).toHaveLength(1);
+    expect(debouncedCalls[0]!.type).toBe("conversation_analyze");
+    expect(debouncedCalls[0]!.payload).toEqual({
+      conversationId: "c1",
+      triggerGroup: "debounced",
+    });
+    expect(debouncedCalls[0]!.runAfter).toBeGreaterThanOrEqual(
+      before + 600_000,
+    );
+    expect(debouncedCalls[0]!.runAfter).toBeLessThanOrEqual(after + 600_000);
+    expect(enqueueCalls).toHaveLength(0);
+  });
+
+  test("flag on, trigger = 'lifecycle', normal source — upsertAutoAnalysisJob called (same as idle)", () => {
+    configValue = { analysis: { idleTimeoutMs: 600_000 } };
+    const before = Date.now();
+
+    enqueueAutoAnalysisIfEnabled({
+      conversationId: "c1",
+      trigger: "lifecycle",
+    });
+
+    const after = Date.now();
+
+    expect(debouncedCalls).toHaveLength(1);
+    expect(debouncedCalls[0]!.type).toBe("conversation_analyze");
+    expect(debouncedCalls[0]!.payload).toEqual({
+      conversationId: "c1",
+      triggerGroup: "debounced",
+    });
+    expect(debouncedCalls[0]!.runAfter).toBeGreaterThanOrEqual(
+      before + 600_000,
+    );
+    expect(debouncedCalls[0]!.runAfter).toBeLessThanOrEqual(after + 600_000);
+    expect(enqueueCalls).toHaveLength(0);
+  });
+
+  test("flag on, source is auto-analysis — no job is enqueued", () => {
+    isAuto = true;
+
+    enqueueAutoAnalysisIfEnabled({ conversationId: "c1", trigger: "batch" });
+    enqueueAutoAnalysisIfEnabled({ conversationId: "c1", trigger: "idle" });
+    enqueueAutoAnalysisIfEnabled({
+      conversationId: "c1",
+      trigger: "lifecycle",
+    });
+
+    expect(enqueueCalls).toHaveLength(0);
+    expect(debouncedCalls).toHaveLength(0);
+  });
+
+  test("flag on, source is private — no job is enqueued for any trigger", () => {
+    // `analyzeConversation` rejects private conversations with FORBIDDEN, so
+    // enqueueing a job for one is guaranteed to fail. Skip silently instead
+    // so we don't create queue/log churn on every private-chat eviction.
+    conversationType = "private";
+
+    enqueueAutoAnalysisIfEnabled({ conversationId: "c1", trigger: "batch" });
+    enqueueAutoAnalysisIfEnabled({ conversationId: "c1", trigger: "idle" });
+    enqueueAutoAnalysisIfEnabled({
+      conversationId: "c1",
+      trigger: "lifecycle",
+    });
+
+    expect(enqueueCalls).toHaveLength(0);
+    expect(debouncedCalls).toHaveLength(0);
+  });
+
+  test("getConfig throws — skips silently without enqueueing", () => {
+    getConfigThrows = true;
+
+    enqueueAutoAnalysisIfEnabled({ conversationId: "c1", trigger: "batch" });
+    enqueueAutoAnalysisIfEnabled({ conversationId: "c1", trigger: "idle" });
+
+    expect(enqueueCalls).toHaveLength(0);
+    expect(debouncedCalls).toHaveLength(0);
+  });
+
+  test("uses fallback idleTimeoutMs (600_000) when config.analysis is absent", () => {
+    // Simulate an older config that doesn't declare `analysis` yet —
+    // `config.analysis?.idleTimeoutMs ?? 600_000` should take the fallback.
+    configValue = {};
+    const before = Date.now();
+
+    enqueueAutoAnalysisIfEnabled({ conversationId: "c1", trigger: "idle" });
+
+    const after = Date.now();
+
+    expect(debouncedCalls).toHaveLength(1);
+    expect(debouncedCalls[0]!.runAfter).toBeGreaterThanOrEqual(
+      before + 600_000,
+    );
+    expect(debouncedCalls[0]!.runAfter).toBeLessThanOrEqual(after + 600_000);
+  });
+
+  test("respects a custom idleTimeoutMs from config", () => {
+    configValue = { analysis: { idleTimeoutMs: 1_000 } };
+    const before = Date.now();
+
+    enqueueAutoAnalysisIfEnabled({
+      conversationId: "c1",
+      trigger: "lifecycle",
+    });
+
+    const after = Date.now();
+
+    expect(debouncedCalls).toHaveLength(1);
+    expect(debouncedCalls[0]!.runAfter).toBeGreaterThanOrEqual(before + 1_000);
+    expect(debouncedCalls[0]!.runAfter).toBeLessThanOrEqual(after + 1_000);
+  });
+
+  test("flag on, trigger = 'compaction', normal source — fires immediately like 'batch'", () => {
+    const before = Date.now();
+
+    enqueueAutoAnalysisIfEnabled({
+      conversationId: "c1",
+      trigger: "compaction",
+    });
+
+    const after = Date.now();
+
+    expect(debouncedCalls).toHaveLength(1);
+    expect(debouncedCalls[0]!.type).toBe("conversation_analyze");
+    expect(debouncedCalls[0]!.payload).toEqual({
+      conversationId: "c1",
+      triggerGroup: "immediate",
+    });
+    // "compaction" fires immediately (runAfter ≈ now) so the reflective
+    // agent runs before the narrowed context window pushes more detail out.
+    expect(debouncedCalls[0]!.runAfter).toBeGreaterThanOrEqual(before);
+    expect(debouncedCalls[0]!.runAfter).toBeLessThanOrEqual(after);
+    expect(enqueueCalls).toHaveLength(0);
+  });
+});
+
+describe("enqueueAutoAnalysisOnCompaction", () => {
+  beforeEach(() => {
+    flagEnabled = true;
+    isAuto = false;
+    conversationType = "standard";
+    getConfigThrows = false;
+    configValue = { analysis: { idleTimeoutMs: 600_000 } };
+    enqueueCalls.length = 0;
+    debouncedCalls.length = 0;
+  });
+
+  test("guardian trust class — enqueues compaction-triggered job immediately", () => {
+    const before = Date.now();
+
+    enqueueAutoAnalysisOnCompaction("c1", "guardian");
+
+    const after = Date.now();
+
+    expect(debouncedCalls).toHaveLength(1);
+    expect(debouncedCalls[0]!.type).toBe("conversation_analyze");
+    expect(debouncedCalls[0]!.payload).toEqual({
+      conversationId: "c1",
+      triggerGroup: "immediate",
+    });
+    expect(debouncedCalls[0]!.runAfter).toBeGreaterThanOrEqual(before);
+    expect(debouncedCalls[0]!.runAfter).toBeLessThanOrEqual(after);
+  });
+
+  test("undefined trust class — skips (fail-closed when trust is unresolved)", () => {
+    // `isUntrustedTrustClass(undefined)` is true in production, so
+    // compaction-triggered analysis must NOT fire when the caller cannot
+    // establish a trust class.
+    enqueueAutoAnalysisOnCompaction("c1", undefined);
+
+    expect(enqueueCalls).toHaveLength(0);
+    expect(debouncedCalls).toHaveLength(0);
+  });
+
+  test("unknown trust class — skips (mirrors memory-extraction trust boundary)", () => {
+    enqueueAutoAnalysisOnCompaction("c1", "unknown");
+
+    expect(enqueueCalls).toHaveLength(0);
+    expect(debouncedCalls).toHaveLength(0);
+  });
+
+  test("trusted_contact trust class — skips (only guardian is trusted)", () => {
+    // trusted_contact is in the untrusted set per production
+    // `isUntrustedTrustClass`, so compaction-triggered analysis must NOT
+    // fire. Only `guardian` passes the gate.
+    enqueueAutoAnalysisOnCompaction("c1", "trusted_contact");
+
+    expect(enqueueCalls).toHaveLength(0);
+    expect(debouncedCalls).toHaveLength(0);
+  });
+
+  test("guardian trust but flag off — helper still gates via enqueueAutoAnalysisIfEnabled", () => {
+    flagEnabled = false;
+
+    enqueueAutoAnalysisOnCompaction("c1", "guardian");
+
+    expect(enqueueCalls).toHaveLength(0);
+    expect(debouncedCalls).toHaveLength(0);
+  });
+
+  test("guardian trust but source is auto-analysis — helper skips via recursion guard", () => {
+    isAuto = true;
+
+    enqueueAutoAnalysisOnCompaction("c1", "guardian");
+
+    expect(enqueueCalls).toHaveLength(0);
+    expect(debouncedCalls).toHaveLength(0);
+  });
+});

package/src/memory/__tests__/auto-analysis-guard.test.ts

@@ -0,0 +1,57 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+import {
+  AUTO_ANALYSIS_GROUP_ID,
+  AUTO_ANALYSIS_SOURCE,
+  isAutoAnalysisConversation,
+} from "../auto-analysis-guard.js";
+import { createConversation } from "../conversation-crud.js";
+import { getDb, initializeDb } from "../db.js";
+
+initializeDb();
+
+function resetTables(): void {
+  const db = getDb();
+  db.run(`DELETE FROM messages`);
+  db.run(`DELETE FROM conversations`);
+}
+
+describe("auto-analysis constants", () => {
+  test("AUTO_ANALYSIS_SOURCE is the canonical 'auto-analysis' string", () => {
+    expect(AUTO_ANALYSIS_SOURCE).toBe("auto-analysis");
+  });
+
+  test("AUTO_ANALYSIS_GROUP_ID is 'system:background' so reflections render as a background sub-group", () => {
+    expect(AUTO_ANALYSIS_GROUP_ID).toBe("system:background");
+  });
+});
+
+describe("isAutoAnalysisConversation", () => {
+  beforeEach(() => {
+    resetTables();
+  });
+
+  test("returns true for a conversation with source = 'auto-analysis'", () => {
+    const conv = createConversation({
+      title: "analysis",
+      source: AUTO_ANALYSIS_SOURCE,
+    });
+    expect(isAutoAnalysisConversation(conv.id)).toBe(true);
+  });
+
+  test("returns false for a conversation with source = 'user'", () => {
+    const conv = createConversation("regular user conversation");
+    expect(isAutoAnalysisConversation(conv.id)).toBe(false);
+  });
+
+  test("returns false for a non-existent conversation", () => {
+    expect(isAutoAnalysisConversation("does-not-exist")).toBe(false);
+  });
+});