@vellumai/assistant 0.10.2-dev.202606250318.5e7cfb0 → 0.10.2

package/src/memory/watchdog-events-store.ts

@@ -1,87 +0,0 @@
-import { and, asc, eq, gt, or } from "drizzle-orm";
-import { v4 as uuid } from "uuid";
-
-import { getCachedShareAnalytics } from "../platform/consent-cache.js";
-import { getTelemetryDb } from "./db-connection.js";
-import { watchdogEvents } from "./schema.js";
-
-/**
- * Input for one `watchdog` telemetry event. Metadata only — never conversation
- * content. `value` and `detail` are optional; omitting both yields the minimal
- * event (check_name only). `detail` is a JSON bag serialized to text on persist
- * and forwarded verbatim on flush.
- */
-export interface WatchdogEventRecord {
-  checkName: string;
-  /** Measured magnitude (block ms, idle ms, ...). Null when the check carries no scalar. */
-  value?: number | null;
-  /** Open JSON bag for extra fields (reason codes, secondary numbers, ...). */
-  detail?: Record<string, unknown> | null;
-}
-
-/** A persisted watchdog event row. */
-export interface WatchdogEvent {
-  id: string;
-  createdAt: number;
-  checkName: string;
-  value: number | null;
-  /** Raw `detail` JSON text from the row, or null. Parsed by the reporter on flush. */
-  detail: string | null;
-}
-
-/**
- * Record a `watchdog` telemetry event for a watchdog check firing. No-ops when
- * usage data collection is disabled (the event is dropped to honor the opt-out,
- * matching the rest of telemetry) — so opt-out rows never exist and the
- * reporter's standard 0 watermark default is safe.
- */
-export function recordWatchdogEvent(record: WatchdogEventRecord): void {
-  if (!getCachedShareAnalytics()) return;
-  const db = getTelemetryDb();
-  if (!db) return;
-  db.insert(watchdogEvents)
-    .values({
-      id: uuid(),
-      createdAt: Date.now(),
-      checkName: record.checkName,
-      value: record.value ?? null,
-      detail: record.detail != null ? JSON.stringify(record.detail) : null,
-    })
-    .run();
-}
-
-/**
- * Query watchdog events that haven't been reported to telemetry yet.
- * Uses a compound cursor (createdAt + id) for reliable watermarking.
- */
-export function queryUnreportedWatchdogEvents(
-  afterCreatedAt: number,
-  afterId: string | undefined,
-  limit: number,
-): WatchdogEvent[] {
-  const db = getTelemetryDb();
-  if (!db) return [];
-  return db
-    .select({
-      id: watchdogEvents.id,
-      createdAt: watchdogEvents.createdAt,
-      checkName: watchdogEvents.checkName,
-      value: watchdogEvents.value,
-      detail: watchdogEvents.detail,
-    })
-    .from(watchdogEvents)
-    .where(
-      afterId
-        ? or(
-            gt(watchdogEvents.createdAt, afterCreatedAt),
-            and(
-              eq(watchdogEvents.createdAt, afterCreatedAt),
-              gt(watchdogEvents.id, afterId),
-            ),
-          )
-        : gt(watchdogEvents.createdAt, afterCreatedAt),
-    )
-    .orderBy(asc(watchdogEvents.createdAt), asc(watchdogEvents.id))
-    .limit(limit)
-    .all();
-}

package/src/memory/worker-control.ts

@@ -1,118 +0,0 @@
-/**
- * Shared control surface for the memory jobs worker *process* — the detached
- * OS process whose entry point is `worker-process.ts`.
- *
- * Both the `assistant memory worker` CLI and the daemon lifecycle (when
- * `memory.worker.enabled` is set) need to probe, spawn, and stop this process,
- * so the PID-file bookkeeping lives here in one place.
- */
-
-import { existsSync, readFileSync, unlinkSync } from "node:fs";
-
-import { getMemoryWorkerPidPath } from "../util/platform.js";
-
-export interface MemoryWorkerStatus {
-  status: "running" | "not_running";
-  pid?: number;
-}
-
-/**
- * Inspect the PID file to determine whether the worker process is alive.
- * A stale PID file (pointing at a dead process) is cleaned up and reported
- * as not_running.
- */
-export function probeMemoryWorker(): MemoryWorkerStatus {
-  const pidPath = getMemoryWorkerPidPath();
-  if (!existsSync(pidPath)) return { status: "not_running" };
-
-  const raw = readFileSync(pidPath, "utf-8").trim();
-  const pid = parseInt(raw, 10);
-  if (!Number.isFinite(pid) || pid <= 0) return { status: "not_running" };
-
-  try {
-    process.kill(pid, 0);
-    return { status: "running", pid };
-  } catch (err: unknown) {
-    if (
-      err &&
-      typeof err === "object" &&
-      "code" in err &&
-      err.code === "ESRCH"
-    ) {
-      // Stale PID file — clean it up.
-      try {
-        unlinkSync(pidPath);
-      } catch {
-        // best-effort
-      }
-      return { status: "not_running" };
-    }
-    throw err;
-  }
-}
-
-export class MemoryWorkerSpawnError extends Error {}
-
-/**
- * Spawn the memory worker as a detached background process.
- *
- * If a worker is already running, returns its PID with `alreadyRunning: true`
- * rather than spawning a second one. Throws {@link MemoryWorkerSpawnError} if
- * the child is spawned but never writes its PID file (i.e. failed to start).
- */
-export async function spawnMemoryWorkerProcess(): Promise<{
-  pid: number;
-  alreadyRunning: boolean;
-}> {
-  const current = probeMemoryWorker();
-  if (current.status === "running" && current.pid != null) {
-    return { pid: current.pid, alreadyRunning: true };
-  }
-
-  const pidPath = getMemoryWorkerPidPath();
-  const entry = new URL("./worker-process.ts", import.meta.url);
-
-  // Spawn detached so the worker survives the spawning process exiting.
-  const child = Bun.spawn({
-    cmd: ["bun", "run", entry.pathname],
-    stdio: ["ignore", "ignore", "ignore"],
-    detached: true,
-  });
-
-  // Unreference so the spawning process doesn't wait for the child.
-  child.unref();
-
-  // Wait briefly for the PID file to appear (the worker writes it on startup).
-  let pidWritten = false;
-  for (let i = 0; i < 10; i++) {
-    await Bun.sleep(100);
-    if (existsSync(pidPath)) {
-      pidWritten = true;
-      break;
-    }
-  }
-
-  if (!pidWritten) {
-    throw new MemoryWorkerSpawnError(
-      "Memory worker was spawned but PID file did not appear within 1s",
-    );
-  }
-
-  const pid = parseInt(readFileSync(pidPath, "utf-8").trim(), 10);
-  return { pid, alreadyRunning: false };
-}
-
-/**
- * Send SIGTERM to the worker process if it is actually running.
- *
- * Returns the status observed before signalling, so callers can report
- * whether anything was stopped. Only throws if `process.kill` itself fails
- * (e.g. EPERM) — a not-running worker is a no-op.
- */
-export function stopMemoryWorkerProcess(): MemoryWorkerStatus {
-  const current = probeMemoryWorker();
-  if (current.status === "running" && current.pid != null) {
-    process.kill(current.pid, "SIGTERM");
-  }
-  return current;
-}

package/src/memory/worker-process.ts

@@ -1,72 +0,0 @@
-/**
- * Standalone entry point for the memory jobs worker as its own OS process.
- *
- * Spawned by `assistant memory worker start`. Loads config, starts the
- * worker loop, writes a PID file, and stays alive until SIGTERM/SIGINT.
- *
- * The worker's internal `setTimeout` calls `.unref()`, which is correct
- * inside the daemon (don't keep the daemon alive for the worker) but would
- * cause this standalone process to exit immediately. A ref'd keep-alive
- * interval prevents that.
- */
-
-import { existsSync, unlinkSync, writeFileSync } from "node:fs";
-
-import { getConfig } from "../config/loader.js";
-import { getLogger } from "../util/logger.js";
-import { getMemoryWorkerPidPath } from "../util/platform.js";
-import { startInProcessMemoryJobsWorker } from "./jobs-worker.js";
-
-const log = getLogger("memory-worker-process");
-
-function cleanupPidFile(): void {
-  const pidPath = getMemoryWorkerPidPath();
-  try {
-    if (existsSync(pidPath)) unlinkSync(pidPath);
-  } catch {
-    // best-effort
-  }
-}
-
-async function main(): Promise<void> {
-  const config = getConfig();
-  const pidPath = getMemoryWorkerPidPath();
-
-  if (config.memory.enabled === false) {
-    log.info("Memory is disabled in config; worker process exiting");
-    process.exit(0);
-  }
-
-  // Write PID file so `status` and `stop` can find us.
-  writeFileSync(pidPath, String(process.pid), { flag: "w" });
-  log.info({ pid: process.pid, pidPath }, "Memory worker process started");
-
-  const worker = startInProcessMemoryJobsWorker();
-
-  // Keep-alive: the worker's setTimeout timers are unref'd, so without
-  // this interval the process would exit immediately.
-  const keepAlive = setInterval(() => {}, 60_000);
-
-  const shutdown = (signal: string) => {
-    log.info({ signal }, "Memory worker process shutting down");
-    worker.stop();
-    clearInterval(keepAlive);
-    cleanupPidFile();
-    process.exit(0);
-  };
-
-  process.on("SIGTERM", () => shutdown("SIGTERM"));
-  process.on("SIGINT", () => shutdown("SIGINT"));
-
-  // Clean up if the process exits unexpectedly through any other path.
-  process.on("exit", () => {
-    worker.stop();
-    cleanupPidFile();
-  });
-}
-
-void main().catch((err) => {
-  log.error({ err }, "Memory worker process failed to start");
-  cleanupPidFile();
-  process.exit(1);
-});

package/src/notifications/__tests__/connected-channels.test.ts

@@ -1,114 +0,0 @@
-/**
- * Tests for getConnectedChannels connectivity resolution.
- *
- * Connectivity must mirror destination-resolver's `resolveGuardian`:
- * gateway-first, with a LOCAL contacts fallback on ANY per-channel no-match
- * (gateway list null OR no active gateway entry for the channel). This keeps a
- * channel from being marked connected when it can't be delivered (and
- * vice-versa).
- */
-
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-import type { GuardianDelivery } from "@vellumai/gateway-client";
-
-mock.module("../../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
-  truncateForLog: (value: string) => value,
-}));
-
-let deliverableChannels: string[] = [];
-let gatewayGuardians: GuardianDelivery[] | null = null;
-let localChatId: string | null = null;
-
-const realConfig = await import("../../channels/config.js");
-
-mock.module("../../channels/config.js", () => ({
-  ...realConfig,
-  getDeliverableChannels: () => deliverableChannels,
-}));
-
-const realReader = await import("../../contacts/guardian-delivery-reader.js");
-
-mock.module("../../contacts/guardian-delivery-reader.js", () => ({
-  ...realReader,
-  getGuardianDelivery: async () => gatewayGuardians,
-}));
-
-const realContactStore = await import("../../contacts/contact-store.js");
-
-mock.module("../../contacts/contact-store.js", () => ({
-  ...realContactStore,
-  findGuardianForChannel: (_channelType: string) =>
-    localChatId === null
-      ? null
-      : { contact: { principalId: "p1" }, channel: { externalChatId: localChatId } },
-}));
-
-const { getConnectedChannels } = await import("../emit-signal.js");
-
-function gatewayBinding(channelType: string, externalChatId: string): GuardianDelivery {
-  return { channelType, contactId: "c1", address: "addr", externalChatId, status: "active" };
-}
-
-beforeEach(() => {
-  deliverableChannels = [];
-  gatewayGuardians = null;
-  localChatId = null;
-});
-
-describe("getConnectedChannels gateway-first-then-local connectivity", () => {
-  test("marks telegram connected from a gateway-only binding", async () => {
-    deliverableChannels = ["telegram"];
-    gatewayGuardians = [gatewayBinding("telegram", "123")];
-    localChatId = null;
-
-    expect(await getConnectedChannels()).toContain("telegram");
-  });
-
-  test("falls back to a local binding when the gateway is unreachable (null)", async () => {
-    deliverableChannels = ["telegram"];
-    gatewayGuardians = null;
-    localChatId = "456";
-
-    expect(await getConnectedChannels()).toContain("telegram");
-  });
-
-  test("marks telegram disconnected when neither source has a binding", async () => {
-    deliverableChannels = ["telegram"];
-    gatewayGuardians = null;
-    localChatId = null;
-
-    expect(await getConnectedChannels()).not.toContain("telegram");
-  });
-
-  test("falls back to local when the gateway responds without that channel", async () => {
-    // Gateway present but with no active telegram entry ⇒ per-channel no-match,
-    // so connectivity falls back to the local mirror (mirrors
-    // destination-resolver's per-channel fallback).
-    deliverableChannels = ["telegram"];
-    gatewayGuardians = [];
-    localChatId = "789";
-
-    expect(await getConnectedChannels()).toContain("telegram");
-  });
-
-  test("only marks slack connected for D-prefixed (DM) chat IDs", async () => {
-    deliverableChannels = ["slack"];
-    gatewayGuardians = [gatewayBinding("slack", "C-public")];
-    expect(await getConnectedChannels()).not.toContain("slack");
-
-    gatewayGuardians = [gatewayBinding("slack", "D-dm")];
-    expect(await getConnectedChannels()).toContain("slack");
-  });
-
-  test("always reports vellum and platform connected", async () => {
-    deliverableChannels = ["vellum", "platform"];
-    gatewayGuardians = null;
-
-    const connected = await getConnectedChannels();
-    expect(connected).toContain("vellum");
-    expect(connected).toContain("platform");
-  });
-});

package/src/notifications/__tests__/destination-resolver.test.ts

@@ -1,256 +0,0 @@
-/**
- * Verifies resolveDestinations resolves guardian delivery endpoints from the
- * gateway-provided guardian list, with shapes identical to the local read, and
- * falls back to the local contacts read when the list is null.
- */
-
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-import type { GuardianDelivery } from "@vellumai/gateway-client";
-
-mock.module("../../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
-// Local fallback read; mocked so the null-list path is deterministic.
-let localGuardian:
-  | { contact: { principalId?: string }; channel: { address: string; externalChatId?: string } }
-  | null = null;
-
-mock.module("../../contacts/contact-store.js", () => ({
-  findGuardianForChannel: (_channelType: string) => localGuardian,
-}));
-
-const { resolveDestinations } = await import("../destination-resolver.js");
-
-function guardian(
-  overrides: Partial<GuardianDelivery> & Pick<GuardianDelivery, "channelType" | "address">,
-): GuardianDelivery {
-  return {
-    contactId: "contact-1",
-    status: "active",
-    ...overrides,
-  } as GuardianDelivery;
-}
-
-describe("resolveDestinations — gateway guardian list", () => {
-  beforeEach(() => {
-    localGuardian = null;
-  });
-
-  test("vellum carries guardianPrincipalId from the gateway list", () => {
-    const list = [
-      guardian({ channelType: "vellum", address: "user@example.com", principalId: "prin-1" }),
-    ];
-    const result = resolveDestinations(["vellum"], list);
-    expect(result.get("vellum")).toEqual({
-      channel: "vellum",
-      metadata: { guardianPrincipalId: "prin-1" },
-    });
-  });
-
-  test("platform carries guardianPrincipalId from the vellum guardian", () => {
-    const list = [
-      guardian({ channelType: "vellum", address: "user@example.com", principalId: "prin-1" }),
-    ];
-    const result = resolveDestinations(["platform"], list);
-    expect(result.get("platform")).toEqual({
-      channel: "platform",
-      metadata: { guardianPrincipalId: "prin-1" },
-    });
-  });
-
-  test("telegram resolves endpoint and binding context", () => {
-    const list = [
-      guardian({
-        channelType: "telegram",
-        address: "tg-user",
-        externalChatId: "12345",
-      }),
-    ];
-    const result = resolveDestinations(["telegram"], list);
-    expect(result.get("telegram")).toEqual({
-      channel: "telegram",
-      endpoint: "12345",
-      metadata: { externalUserId: "tg-user" },
-      bindingContext: {
-        sourceChannel: "telegram",
-        externalChatId: "12345",
-        externalUserId: "tg-user",
-      },
-    });
-  });
-
-  test("telegram without externalChatId is omitted", () => {
-    const list = [guardian({ channelType: "telegram", address: "tg-user" })];
-    const result = resolveDestinations(["telegram"], list);
-    expect(result.has("telegram")).toBe(false);
-  });
-
-  test("slack resolves DM endpoint and binding context", () => {
-    const list = [
-      guardian({
-        channelType: "slack",
-        address: "slack-user",
-        externalChatId: "D123",
-      }),
-    ];
-    const result = resolveDestinations(["slack"], list);
-    expect(result.get("slack")).toEqual({
-      channel: "slack",
-      endpoint: "D123",
-      metadata: { externalUserId: "slack-user" },
-      bindingContext: {
-        sourceChannel: "slack",
-        externalChatId: "D123",
-        externalUserId: "slack-user",
-      },
-    });
-  });
-
-  test("slack non-DM channel is dropped", () => {
-    const list = [
-      guardian({
-        channelType: "slack",
-        address: "slack-user",
-        externalChatId: "C123",
-      }),
-    ];
-    const result = resolveDestinations(["slack"], list);
-    expect(result.has("slack")).toBe(false);
-  });
-
-  test("inactive guardian is ignored", () => {
-    const list = [
-      guardian({
-        channelType: "telegram",
-        address: "tg-user",
-        externalChatId: "12345",
-        status: "revoked",
-      }),
-    ];
-    const result = resolveDestinations(["telegram"], list);
-    expect(result.has("telegram")).toBe(false);
-  });
-});
-
-describe("resolveDestinations — null list falls back to local read", () => {
-  beforeEach(() => {
-    localGuardian = null;
-  });
-
-  test("telegram resolves from the local contacts read", () => {
-    localGuardian = {
-      contact: {},
-      channel: { address: "tg-user", externalChatId: "12345" },
-    };
-    const result = resolveDestinations(["telegram"], null);
-    expect(result.get("telegram")).toEqual({
-      channel: "telegram",
-      endpoint: "12345",
-      metadata: { externalUserId: "tg-user" },
-      bindingContext: {
-        sourceChannel: "telegram",
-        externalChatId: "12345",
-        externalUserId: "tg-user",
-      },
-    });
-  });
-
-  test("slack DM resolves from the local contacts read", () => {
-    localGuardian = {
-      contact: {},
-      channel: { address: "slack-user", externalChatId: "D123" },
-    };
-    const result = resolveDestinations(["slack"], null);
-    expect(result.get("slack")).toEqual({
-      channel: "slack",
-      endpoint: "D123",
-      metadata: { externalUserId: "slack-user" },
-      bindingContext: {
-        sourceChannel: "slack",
-        externalChatId: "D123",
-        externalUserId: "slack-user",
-      },
-    });
-  });
-
-  test("vellum carries principalId from the local contacts read", () => {
-    localGuardian = {
-      contact: { principalId: "prin-1" },
-      channel: { address: "user@example.com" },
-    };
-    const result = resolveDestinations(["vellum"], null);
-    expect(result.get("vellum")).toEqual({
-      channel: "vellum",
-      metadata: { guardianPrincipalId: "prin-1" },
-    });
-  });
-});
-
-describe("resolveDestinations — gateway yields no channel match falls back to local", () => {
-  beforeEach(() => {
-    localGuardian = null;
-  });
-
-  test("empty gateway list falls back to local telegram binding", () => {
-    localGuardian = {
-      contact: {},
-      channel: { address: "tg-user", externalChatId: "12345" },
-    };
-    const result = resolveDestinations(["telegram"], []);
-    expect(result.get("telegram")).toEqual({
-      channel: "telegram",
-      endpoint: "12345",
-      metadata: { externalUserId: "tg-user" },
-      bindingContext: {
-        sourceChannel: "telegram",
-        externalChatId: "12345",
-        externalUserId: "tg-user",
-      },
-    });
-  });
-
-  test("gateway list missing the channel falls back to local slack DM", () => {
-    localGuardian = {
-      contact: {},
-      channel: { address: "slack-user", externalChatId: "D123" },
-    };
-    // Gateway returns a telegram guardian but no slack entry.
-    const list = [
-      guardian({ channelType: "telegram", address: "tg", externalChatId: "999" }),
-    ];
-    const result = resolveDestinations(["slack"], list);
-    expect(result.get("slack")).toEqual({
-      channel: "slack",
-      endpoint: "D123",
-      metadata: { externalUserId: "slack-user" },
-      bindingContext: {
-        sourceChannel: "slack",
-        externalChatId: "D123",
-        externalUserId: "slack-user",
-      },
-    });
-  });
-
-  test("empty gateway list falls back to local vellum principalId", () => {
-    localGuardian = {
-      contact: { principalId: "prin-1" },
-      channel: { address: "user@example.com" },
-    };
-    const result = resolveDestinations(["vellum"], []);
-    expect(result.get("vellum")).toEqual({
-      channel: "vellum",
-      metadata: { guardianPrincipalId: "prin-1" },
-    });
-  });
-
-  test("empty gateway list with no local binding omits telegram", () => {
-    localGuardian = null;
-    const result = resolveDestinations(["telegram"], []);
-    expect(result.has("telegram")).toBe(false);
-  });
-});