@vellumai/assistant 0.11.5 → 0.11.6-staging.1

package/src/__tests__/app-pin-store.test.ts

@@ -0,0 +1,149 @@
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  listAppPins,
+  removeAppPin,
+  updateAppPin,
+} from "../apps/app-pin-store.js";
+import { getDb } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
+import { appPins } from "../persistence/schema/index.js";
+
+await initializeDb();
+
+function pin(appId: string): void {
+  updateAppPin(appId, { pinned: true });
+}
+
+function order(): string[] {
+  return listAppPins().map((entry) => entry.appId);
+}
+
+function positionOf(appId: string): number | undefined {
+  return listAppPins().find((entry) => entry.appId === appId)?.sortPosition;
+}
+
+beforeEach(() => {
+  getDb().delete(appPins).run();
+});
+
+describe("pinning", () => {
+  test("appends each new pin after the last", () => {
+    pin("a");
+    pin("b");
+    pin("c");
+
+    expect(order()).toEqual(["a", "b", "c"]);
+  });
+
+  test("pinning an already-pinned app leaves its position alone", () => {
+    pin("a");
+    pin("b");
+    const before = positionOf("a");
+
+    pin("a");
+
+    expect(positionOf("a")).toBe(before!);
+    expect(order()).toEqual(["a", "b"]);
+  });
+
+  test("reports the resulting pin, and null once unpinned", () => {
+    expect(updateAppPin("a", { pinned: true })).toMatchObject({ appId: "a" });
+    expect(updateAppPin("a", { pinned: false })).toBeNull();
+  });
+
+  test("an unpin with nothing pinned is a no-op, not a throw", () => {
+    expect(updateAppPin("ghost", { pinned: false })).toBeNull();
+    expect(listAppPins()).toEqual([]);
+  });
+});
+
+/*
+ * Positions are a fractional index, so removing one leaves the others exactly
+ * where they were. Asserted by value rather than by relative order, which would
+ * hold either way and would not catch a rewrite that renumbers the survivors.
+ */
+describe("unpinning", () => {
+  test("leaves the surviving positions untouched", () => {
+    pin("a");
+    pin("b");
+    pin("c");
+    const positions = { a: positionOf("a"), c: positionOf("c") };
+
+    updateAppPin("b", { pinned: false });
+
+    expect(order()).toEqual(["a", "c"]);
+    expect(positionOf("a")).toBe(positions.a!);
+    expect(positionOf("c")).toBe(positions.c!);
+  });
+
+  test("a pin taken after an unpin lands last, not on a survivor", () => {
+    pin("a");
+    pin("b");
+    updateAppPin("a", { pinned: false });
+
+    pin("c");
+
+    expect(order()).toEqual(["b", "c"]);
+    expect(positionOf("c")).toBeGreaterThan(positionOf("b")!);
+  });
+
+  test("removeAppPin drops the pin", () => {
+    pin("a");
+    pin("b");
+
+    removeAppPin("a");
+
+    expect(order()).toEqual(["b"]);
+  });
+
+  test("removeAppPin for an unpinned app changes nothing", () => {
+    pin("a");
+
+    removeAppPin("ghost");
+
+    expect(order()).toEqual(["a"]);
+  });
+});
+
+describe("colour", () => {
+  test("sets and clears without disturbing the position", () => {
+    pin("a");
+    pin("b");
+    const before = positionOf("b");
+
+    updateAppPin("b", { color: "teal" });
+    expect(listAppPins()[1]?.color).toBe("teal");
+    expect(positionOf("b")).toBe(before!);
+
+    updateAppPin("b", { color: null });
+    expect(listAppPins()[1]?.color).toBeUndefined();
+    expect(positionOf("b")).toBe(before!);
+  });
+
+  test("survives a later pin call that says nothing about colour", () => {
+    pin("a");
+    updateAppPin("a", { color: "teal" });
+
+    updateAppPin("a", { pinned: true });
+
+    expect(listAppPins()[0]?.color).toBe("teal");
+  });
+
+  /* Otherwise a colour set on an app the user just unpinned would put the pin
+     back, and the sidebar would grow a row nobody asked for. */
+  test("a colour for an unpinned app creates no pin", () => {
+    expect(updateAppPin("ghost", { color: "teal" })).toBeNull();
+    expect(listAppPins()).toEqual([]);
+  });
+
+  test("unpinning takes the colour with it", () => {
+    pin("a");
+    updateAppPin("a", { color: "teal" });
+
+    updateAppPin("a", { pinned: false });
+    pin("a");
+
+    expect(listAppPins()[0]?.color).toBeUndefined();
+  });
+});

package/src/__tests__/channel-availability-routes.test.ts

@@ -1,7 +1,8 @@
 /**
  * Tests for `assistant/src/runtime/routes/channel-availability-routes.ts`.
  *
- * The handler returns a fixed base list (`slack`, `telegram`, `phone`) and
+ * The handler returns a fixed base list (`slack`, `telegram`, `discord`,
+ * `phone`) and
  * appends `email` when the platform reports at least one registered email
  * address for this assistant. Platform failures fall back to base-only.
  *
@@ -90,6 +91,7 @@ describe("channels/available", () => {
     expect(result.channels.map((c) => c.id)).toEqual([
       "slack",
       "telegram",
+      "discord",
       "phone",
     ]);
   });
@@ -106,6 +108,7 @@ describe("channels/available", () => {
     expect(result.channels.map((c) => c.id)).toEqual([
       "slack",
       "telegram",
+      "discord",
       "phone",
       "email",
     ]);
@@ -135,6 +138,7 @@ describe("channels/available", () => {
     expect(result.channels.map((c) => c.id)).toEqual([
       "slack",
       "telegram",
+      "discord",
       "phone",
     ]);
   });
@@ -147,6 +151,7 @@ describe("channels/available", () => {
     expect(result.channels.map((c) => c.id)).toEqual([
       "slack",
       "telegram",
+      "discord",
       "phone",
     ]);
   });
@@ -159,6 +164,7 @@ describe("channels/available", () => {
     expect(result.channels.map((c) => c.id)).toEqual([
       "slack",
       "telegram",
+      "discord",
       "phone",
     ]);
   });
@@ -216,4 +222,20 @@ describe("channels/available", () => {
       expect(ch!.setupMessages.contact.length).toBeGreaterThan(0);
     }
   });
+
+  test("offers Discord for verification, like the other text channels", async () => {
+    const result = (await handler({})) as HandlerResult;
+
+    const discord = result.channels.find((c) => c.id === "discord");
+    // Availability is what a client reads to decide whether to offer setup at
+    // all, so a channel absent here can never be verified however complete its
+    // transport is.
+    expect(discord).toBeDefined();
+    expect(discord!.supportsVerification).toBe(true);
+    expect(discord!.source).toBe("default");
+    expect(discord!.setupMessages.guardian).toContain("Discord");
+    // This field carries a Lucide name, which a brand mark is not. A client
+    // with room for one picks it by channel; every client can draw this.
+    expect(discord!.icon).toBe("hash");
+  });
 });

package/src/__tests__/channel-readiness-discord.test.ts

@@ -0,0 +1,231 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { credentialKey } from "../security/credential-key.js";
+
+let mockSecureKeys: Record<string, string>;
+
+mock.module("../security/secure-keys.js", () => ({
+  getSecureKeyAsync: async (key: string) => mockSecureKeys[key] ?? null,
+  setSecureKeyAsync: async (key: string, value: string) => {
+    mockSecureKeys[key] = value;
+    return true;
+  },
+  deleteSecureKeyAsync: async (key: string) => {
+    delete mockSecureKeys[key];
+    return true;
+  },
+}));
+
+mock.module("../calls/twilio-rest.js", () => ({
+  hasTwilioCredentials: () => false,
+}));
+
+mock.module("../calls/twilio-config.js", () => ({
+  resolveTwilioPhoneNumber: () => undefined,
+}));
+
+mock.module("./channel-invite-transports/whatsapp.js", () => ({
+  resolveWhatsAppDisplayNumber: () => undefined,
+}));
+
+type SocketHealth = {
+  channel: string;
+  status: "connected" | "disconnected" | "not_configured" | "unsupported";
+  lastLivenessAt?: number;
+};
+
+/**
+ * Every channel the socket-health reader was asked about, in order.
+ *
+ * The reader takes the channel as an argument and one function serves every
+ * socket-backed channel, so a probe naming the wrong one reports a different
+ * channel's connection as its own and no type notices.
+ */
+let askedChannels: string[];
+let socketHealth: SocketHealth | Error;
+
+/** How many channels the gateway reports on Discord's allow-list. */
+let admittedChannelCount: number | Error;
+
+mock.module("../channels/gateway-discord-admission.js", () => ({
+  readDiscordAdmission: async () => {
+    if (admittedChannelCount instanceof Error) {
+      throw admittedChannelCount;
+    }
+    return { admittedChannelCount };
+  },
+}));
+
+mock.module("../channels/gateway-channel-socket-health.js", () => ({
+  readChannelSocketHealth: async (channel: string) => {
+    askedChannels.push(channel);
+    if (socketHealth instanceof Error) {
+      throw socketHealth;
+    }
+    return socketHealth;
+  },
+}));
+
+beforeEach(() => {
+  mockSecureKeys = {};
+  askedChannels = [];
+  socketHealth = { channel: "discord", status: "connected" };
+  // The default install state: fail-closed and empty, admitting nothing until
+  // someone lists channel ids. Tests that need admission say so.
+  admittedChannelCount = 0;
+});
+
+async function runDiscordProbe() {
+  const { createReadinessService } =
+    await import("../runtime/channel-readiness-service.js");
+  return createReadinessService().getReadiness("discord", false);
+}
+
+function findCheck(
+  snapshot: Awaited<ReturnType<typeof runDiscordProbe>>[number],
+  name: string,
+) {
+  return snapshot.localChecks.find((c) => c.name === name)!;
+}
+
+describe("discord readiness", () => {
+  test("asks the gateway about Discord's own socket", async () => {
+    await runDiscordProbe();
+
+    expect(askedChannels).toEqual(["discord"]);
+  });
+
+  test("a fresh install has neither a token nor an allow-list", async () => {
+    const [snapshot] = await runDiscordProbe();
+
+    expect(findCheck(snapshot, "bot_token").passed).toBe(false);
+    expect(findCheck(snapshot, "guild_admission").passed).toBe(false);
+    // Nothing configured at all, which is a different report from a channel
+    // half set up: no step has been taken rather than one left undone.
+    expect(snapshot.setupStatus).toBe("not_configured");
+  });
+
+  test("an allow-list without a token is half set up", async () => {
+    admittedChannelCount = 3;
+
+    const [snapshot] = await runDiscordProbe();
+
+    expect(findCheck(snapshot, "bot_token").passed).toBe(false);
+    expect(snapshot.setupStatus).toBe("incomplete");
+  });
+
+  test("a token, a live connection and an allow-list read as ready", async () => {
+    mockSecureKeys[credentialKey("discord_channel", "bot_token")] = "bot-fake";
+    admittedChannelCount = 2;
+    socketHealth = {
+      channel: "discord",
+      status: "connected",
+      lastLivenessAt: Date.parse("2026-08-21T17:00:00.000Z"),
+    };
+
+    const [snapshot] = await runDiscordProbe();
+
+    expect(findCheck(snapshot, "bot_token").passed).toBe(true);
+    const delivery = findCheck(snapshot, "inbound_delivery");
+    expect(delivery.passed).toBe(true);
+    expect(delivery.message).toContain("Discord");
+    expect(delivery.message).toContain("2026-08-21T17:00:00.000Z");
+    expect(findCheck(snapshot, "guild_admission").message).toContain(
+      "2 channels",
+    );
+    expect(snapshot.ready).toBe(true);
+  });
+
+  test("an empty allow-list is unfinished setup, not a live channel", async () => {
+    mockSecureKeys[credentialKey("discord_channel", "bot_token")] = "bot-fake";
+    admittedChannelCount = 0;
+
+    const [snapshot] = await runDiscordProbe();
+
+    // A connected socket that admits nothing still drops every guild message,
+    // so claiming ready here would promise delivery the gate is refusing.
+    const admission = findCheck(snapshot, "guild_admission");
+    expect(admission.passed).toBe(false);
+    expect(snapshot.setupStatus).toBe("incomplete");
+    expect(snapshot.ready).toBe(false);
+
+    // And it is a setup step rather than an outage: direct messages carry no
+    // guild and never meet this gate, so the connection itself is fine.
+    expect(snapshot.health).not.toBe("failing");
+    expect(findCheck(snapshot, "inbound_delivery").passed).toBe(true);
+  });
+
+  test("one admitted channel reads in the singular", async () => {
+    mockSecureKeys[credentialKey("discord_channel", "bot_token")] = "bot-fake";
+    admittedChannelCount = 1;
+
+    const [snapshot] = await runDiscordProbe();
+
+    expect(findCheck(snapshot, "guild_admission").message).toContain(
+      "1 channel",
+    );
+    expect(findCheck(snapshot, "guild_admission").message).not.toContain(
+      "1 channels",
+    );
+  });
+
+  test("an unreachable gateway does not claim the allow-list is empty", async () => {
+    mockSecureKeys[credentialKey("discord_channel", "bot_token")] = "bot-fake";
+    admittedChannelCount = new Error("gateway down");
+
+    const [snapshot] = await runDiscordProbe();
+
+    const admission = findCheck(snapshot, "guild_admission");
+    expect(admission.passed).toBe(true);
+    expect(admission.indeterminate).toBe(true);
+  });
+
+  test("a dead socket reads as configured and failing, not unconfigured", async () => {
+    mockSecureKeys[credentialKey("discord_channel", "bot_token")] = "bot-fake";
+    // Setup has to be finished for this to isolate the socket: an empty
+    // allow-list would leave it incomplete for a reason that is not the socket.
+    admittedChannelCount = 1;
+    socketHealth = { channel: "discord", status: "disconnected" };
+
+    const [snapshot] = await runDiscordProbe();
+
+    // The distinction the operational kind exists for: setup finished, and the
+    // channel is down. Reporting it as unconfigured would send someone back
+    // through a setup flow that has nothing left to do.
+    expect(snapshot.setupStatus).toBe("ready");
+    expect(snapshot.health).toBe("failing");
+    expect(snapshot.ready).toBe(false);
+    expect(findCheck(snapshot, "inbound_delivery").message).toMatch(
+      /not reaching this assistant/i,
+    );
+  });
+
+  test("an unreachable gateway is indeterminate, never a fault", async () => {
+    mockSecureKeys[credentialKey("discord_channel", "bot_token")] = "bot-fake";
+    socketHealth = new Error("gateway down");
+
+    const [snapshot] = await runDiscordProbe();
+
+    const delivery = findCheck(snapshot, "inbound_delivery");
+    expect(delivery.passed).toBe(true);
+    expect(delivery.indeterminate).toBe(true);
+    // Not evidence of a fault, so it may not show the channel as broken, and
+    // not evidence of delivery either, so it may not make it ready.
+    expect(snapshot.health).not.toBe("failing");
+  });
+
+  test("Discord runs no remote checks, so nothing calls out to it", async () => {
+    mockSecureKeys[credentialKey("discord_channel", "bot_token")] = "bot-fake";
+
+    const { createReadinessService } =
+      await import("../runtime/channel-readiness-service.js");
+    const [snapshot] = await createReadinessService().getReadiness(
+      "discord",
+      true,
+    );
+
+    // One bot token serves both the gateway connection and the sends, so a
+    // live socket already proves the credential a send would use.
+    expect(snapshot.remoteChecks ?? []).toEqual([]);
+  });
+});

package/src/__tests__/channel-readiness-service.test.ts

@@ -566,3 +566,129 @@ describe("ChannelReadinessService", () => {
     expect(probe.remoteCallCount).toBe(1);
   });
 });
+
+describe("setup progress and operational health are separate axes", () => {
+  const configured = (name: string): ReadinessCheckResult => ({
+    name,
+    passed: true,
+    message: "configured",
+  });
+
+  test("a configured channel whose delivery fails is set up, not half set up", () => {
+    // The defect this separates: telling the owner of a fully configured
+    // channel to finish setup sends them to fix the one thing that is not
+    // broken. Setup is done; delivery is down.
+    const service = new ChannelReadinessService();
+    service.registerProbe(
+      makeProbe(
+        "phone",
+        [configured("creds")],
+        [
+          {
+            name: "inbound_delivery",
+            passed: false,
+            message: "nothing is arriving",
+            kind: "operational",
+          },
+        ],
+      ),
+    );
+
+    return service.getReadiness("phone", true).then(([snapshot]) => {
+      expect(snapshot.setupStatus).toBe("ready");
+      expect(snapshot.health).toBe("failing");
+      expect(snapshot.ready).toBe(false);
+    });
+  });
+
+  test("a delivery check that establishes nothing reads unknown, not failing", async () => {
+    const service = new ChannelReadinessService();
+    service.registerProbe(
+      makeProbe(
+        "phone",
+        [configured("creds")],
+        [
+          {
+            name: "inbound_delivery",
+            passed: true,
+            indeterminate: true,
+            message: "could not reach the provider",
+            kind: "operational",
+          },
+        ],
+      ),
+    );
+
+    const [snapshot] = await service.getReadiness("phone", true);
+    expect(snapshot.setupStatus).toBe("ready");
+    expect(snapshot.health).toBe("unknown");
+    // Unknown is not proof, so it cannot make the channel ready, and it is
+    // not a fault, so it must not be reported as one.
+    expect(snapshot.ready).toBe(false);
+    expect(snapshot.reasons).toEqual([]);
+  });
+
+  test("a channel that measures nothing operational reports no health at all", async () => {
+    // Absent, not "unknown": nothing was asked, so nothing is claimed, and
+    // readiness rests on configuration alone. This is the shape every channel
+    // without a delivery check still has today.
+    const service = new ChannelReadinessService();
+    service.registerProbe(makeProbe("phone", [configured("creds")]));
+
+    const [snapshot] = await service.getReadiness("phone", true);
+    expect(snapshot.health).toBeUndefined();
+    expect(snapshot.setupStatus).toBe("ready");
+    expect(snapshot.ready).toBe(true);
+  });
+
+  test("incomplete configuration still reads incomplete", async () => {
+    const service = new ChannelReadinessService();
+    service.registerProbe(
+      makeProbe("phone", [
+        configured("creds"),
+        { name: "ingress", passed: false, message: "no public URL" },
+      ]),
+    );
+
+    const [snapshot] = await service.getReadiness("phone", true);
+    expect(snapshot.setupStatus).toBe("incomplete");
+    expect(snapshot.ready).toBe(false);
+  });
+
+  test("an untouched channel is not_configured, not incomplete", async () => {
+    const service = new ChannelReadinessService();
+    service.registerProbe(
+      makeProbe("phone", [
+        { name: "creds", passed: false, message: "not configured" },
+      ]),
+    );
+
+    const [snapshot] = await service.getReadiness("phone", true);
+    expect(snapshot.setupStatus).toBe("not_configured");
+    expect(snapshot.ready).toBe(false);
+  });
+
+  test("ready still means every check verified, exactly as before", async () => {
+    // The safety property for this change: splitting the derivation must not
+    // move `ready` for any input, because the CLI and the web both gate on it.
+    const service = new ChannelReadinessService();
+    service.registerProbe(
+      makeProbe(
+        "phone",
+        [configured("creds")],
+        [
+          {
+            name: "inbound_delivery",
+            passed: true,
+            message: "arriving",
+            kind: "operational",
+          },
+        ],
+      ),
+    );
+
+    const [snapshot] = await service.getReadiness("phone", true);
+    expect(snapshot.ready).toBe(true);
+    expect(snapshot.health).toBe("ok");
+  });
+});