@vellumai/assistant 0.11.5 → 0.11.6-staging.1

package/src/apps/app-pin-reconciler.ts

@@ -0,0 +1,92 @@
+/**
+ * Level-based reconciler converging `app_pins` onto the apps that exist.
+ *
+ * A workspace app's id is a UUID, so a pin left behind when one is deleted can
+ * never be adopted and the app list simply never returns it. A plugin app's id
+ * is a path identity, `plugins~<plugin>~<appDir>`, and `listPluginApps` omits a
+ * plugin that is disabled or uninstalled. Retiring one and bringing it back
+ * rebuilds the same id, so a pin left behind returns to the sidebar with it,
+ * for an app the user had no way to unpin while it was hidden. Converging on
+ * every plugin-set change is what keeps a retirement from being undone.
+ *
+ * Triggers mirror `schedule/plugin-schedule-reconciler.ts`, which solves the
+ * same problem for plugin-declared schedules: daemon startup
+ * (`daemon/lifecycle.ts`), plugin-set convergence (`plugins/mtime-cache.ts`),
+ * and a periodic backstop sweep (`runtime/http-server.ts`) that covers the
+ * `.disabled` sentinel, which the CLI flips out of process without poking the
+ * source reconcile.
+ *
+ * Self-contained in the same way: it never throws, and it checks database
+ * readiness itself rather than relying on its callers to be ordered after
+ * migrations.
+ */
+
+import { getDbMigrationReadiness } from "../daemon/daemon-readiness.js";
+import { publishAppsChanged } from "../runtime/sync/resource-sync-events.js";
+import { getLogger } from "../util/logger.js";
+import { listAppPins, removeAppPin } from "./app-pin-store.js";
+import { listApps, listPluginApps } from "./app-store.js";
+
+const log = getLogger("app-pin-reconciler");
+
+/** How often the backstop sweep converges, matching the schedule reconciler. */
+const SWEEP_INTERVAL_MS = 60_000;
+
+let sweepTimer: ReturnType<typeof setInterval> | null = null;
+let sweepInProgress = false;
+
+/** Drop every pin whose app is not currently installed. Never throws. */
+export function reconcileAppPins(): void {
+  if (!getDbMigrationReadiness().ready) {
+    return;
+  }
+  try {
+    const live = new Set([
+      ...listApps().map((app) => app.id),
+      ...listPluginApps().map((app) => app.id),
+    ]);
+    const stale = listAppPins().filter((pin) => !live.has(pin.appId));
+    for (const pin of stale) {
+      removeAppPin(pin.appId);
+    }
+    if (stale.length > 0) {
+      log.info(
+        { removed: stale.map((pin) => pin.appId) },
+        "Dropped pins for apps that are no longer installed",
+      );
+      /* A pass has no originating client, and every other pin write announces
+         itself, so a client would otherwise keep rendering a pin this just
+         deleted until some unrelated refetch. */
+      publishAppsChanged();
+    }
+  } catch (err) {
+    log.error({ err }, "app pin reconcile failed");
+  }
+}
+
+/** Start the periodic backstop sweep. Idempotent. */
+export function startAppPinReconcileSweep(): void {
+  if (sweepTimer) {
+    return;
+  }
+  sweepTimer = setInterval(() => {
+    if (sweepInProgress) {
+      return;
+    }
+    sweepInProgress = true;
+    try {
+      reconcileAppPins();
+    } finally {
+      sweepInProgress = false;
+    }
+  }, SWEEP_INTERVAL_MS);
+}
+
+/** Stop the periodic sweep. Used in tests and shutdown. */
+export function stopAppPinReconcileSweep(): void {
+  if (sweepTimer) {
+    clearInterval(sweepTimer);
+    sweepTimer = null;
+  }
+  sweepInProgress = false;
+}

package/src/apps/app-pin-store.ts

@@ -0,0 +1,125 @@
+/**
+ * Which apps the user pinned to the sidebar, and in what order.
+ *
+ * Rows hold ids alone. Name and icon are read from the app itself at list
+ * time, so a renamed app renames its pin, and a pin whose app is gone surfaces
+ * nowhere.
+ */
+
+import { eq, max } from "drizzle-orm";
+
+import { getDb } from "../persistence/db-connection.js";
+import { appPins } from "../persistence/schema/index.js";
+
+export interface AppPin {
+  appId: string;
+  /** Fractional index. Ascending is sidebar order; the values are not dense. */
+  sortPosition: number;
+  /** An id from the client's pinned-app colour registry. Absent when unset. */
+  color?: string;
+}
+
+function toPin(row: {
+  appId: string;
+  sortPosition: number;
+  color: string | null;
+}): AppPin {
+  return {
+    appId: row.appId,
+    sortPosition: row.sortPosition,
+    ...(row.color === null ? {} : { color: row.color }),
+  };
+}
+
+/** Every pin, in sidebar order. */
+export function listAppPins(): AppPin[] {
+  return getDb()
+    .select()
+    .from(appPins)
+    .orderBy(appPins.sortPosition)
+    .all()
+    .map(toPin);
+}
+
+function getAppPin(appId: string): AppPin | null {
+  const row = getDb()
+    .select()
+    .from(appPins)
+    .where(eq(appPins.appId, appId))
+    .get();
+  return row ? toPin(row) : null;
+}
+
+/** One past the last pin, so pinning appends. */
+function nextSortPosition(): number {
+  const highest = getDb()
+    .select({ value: max(appPins.sortPosition) })
+    .from(appPins)
+    .get();
+  return (highest?.value ?? 0) + 1;
+}
+
+export interface AppPinUpdate {
+  /** Pin or unpin. Omitted leaves the app's pinned state as it stands. */
+  pinned?: boolean;
+  /** Set (string) or clear (`null`) the colour. Omitted leaves it as it stands. */
+  color?: string | null;
+}
+
+/**
+ * Apply a pin change and return the app's resulting pin, or `null` once it is
+ * no longer pinned.
+ *
+ * A colour for an app that is not pinned is dropped, so a colour can never
+ * conjure a pin that unpinning just removed.
+ */
+export function updateAppPin(
+  appId: string,
+  update: AppPinUpdate,
+): AppPin | null {
+  if (update.pinned === false) {
+    removeAppPin(appId);
+    return null;
+  }
+
+  const existing = getAppPin(appId);
+  if (!existing && update.pinned !== true) {
+    return null;
+  }
+
+  const color = update.color === undefined ? existing?.color : update.color;
+  const db = getDb();
+  const sortPosition = existing?.sortPosition ?? nextSortPosition();
+
+  if (existing) {
+    db.update(appPins)
+      .set({ color: color ?? null })
+      .where(eq(appPins.appId, appId))
+      .run();
+  } else {
+    /* `onConflictDoUpdate` rather than a plain insert: two clients pinning the
+       same app at once would otherwise race on the primary key. */
+    db.insert(appPins)
+      .values({
+        appId,
+        sortPosition,
+        color: color ?? null,
+        createdAt: Date.now(),
+      })
+      .onConflictDoUpdate({
+        target: appPins.appId,
+        set: { color: color ?? null },
+      })
+      .run();
+  }
+
+  return { appId, sortPosition, ...(color == null ? {} : { color }) };
+}
+
+/**
+ * Drop an app's pin as part of deleting it, so the pin does not outlive the app
+ * it points at. A no-op when the app was not pinned.
+ */
+export function removeAppPin(appId: string): void {
+  getDb().delete(appPins).where(eq(appPins.appId, appId)).run();
+}

package/src/channels/gateway-channel-socket-health.ts

@@ -0,0 +1,32 @@
+/**
+ * Daemon-side reader for whether a socket-backed channel is receiving.
+ *
+ * The gateway holds the inbound sockets; the readiness surface that reports
+ * channel health to the user lives here. This is the relay between them.
+ */
+
+import {
+  type ChannelSocketHealthIpcParams,
+  type ChannelSocketHealthIpcResponse,
+  ChannelSocketHealthIpcResponseSchema,
+} from "@vellumai/gateway-client/gateway-ipc-contracts";
+
+import { ipcCallPersistentValidated } from "../ipc/gateway-validated-call.js";
+
+/**
+ * Ask the gateway whether `channel`'s inbound socket is live.
+ *
+ * Throws on transport failure rather than reporting a channel as down: an
+ * unreachable gateway is a fact about the gateway, and a caller that renders
+ * it as "Slack is disconnected" would be inventing an outage. Callers are
+ * expected to treat a throw as indeterminate.
+ */
+export async function readChannelSocketHealth(
+  channel: ChannelSocketHealthIpcParams["channel"],
+): Promise<ChannelSocketHealthIpcResponse> {
+  return ipcCallPersistentValidated(
+    "channel_socket_health",
+    { channel },
+    ChannelSocketHealthIpcResponseSchema,
+  );
+}

package/src/channels/gateway-discord-admission.ts

@@ -0,0 +1,32 @@
+/**
+ * Daemon-side reader for how much Discord admits.
+ *
+ * The gateway owns the allow-list and the drop decision it feeds; the
+ * readiness surface that reports channel setup to the user lives here. This is
+ * the relay between them, and it exists for the same reason the socket-health
+ * relay does: the fact lives on one side of the boundary and is reported from
+ * the other.
+ */
+
+import {
+  type DiscordAdmissionIpcResponse,
+  DiscordAdmissionIpcResponseSchema,
+} from "@vellumai/gateway-client/gateway-ipc-contracts";
+
+import { ipcCallPersistentValidated } from "../ipc/gateway-validated-call.js";
+
+/**
+ * Ask the gateway how many channels Discord's allow-list admits.
+ *
+ * Throws on transport failure rather than reporting zero: an unreachable
+ * gateway is a fact about the gateway, and answering zero would tell an
+ * operator their allow-list is empty when nobody looked. Callers treat a throw
+ * as indeterminate.
+ */
+export async function readDiscordAdmission(): Promise<DiscordAdmissionIpcResponse> {
+  return ipcCallPersistentValidated(
+    "discord_admission",
+    {},
+    DiscordAdmissionIpcResponseSchema,
+  );
+}

package/src/channels/types.ts

@@ -111,6 +111,26 @@ export const CHANNEL_METADATA: Partial<Record<ChannelId, ChannelInfo>> = {
         "I'd like to verify a contact's Telegram identity. Can you walk me through it?",
     },
   },
+  discord: {
+    id: "discord",
+    label: "Discord",
+    subtitle: "Message your assistant from Discord",
+    // A Lucide name, per this field's contract, and the same one Slack
+    // carries: both name their text channels with a hash. A client with room
+    // for a brand mark uses one, which is how Slack's header already works.
+    icon: "hash",
+    // Verification needs nothing channel-specific here. The inbound intercept
+    // that matches a code takes the source channel as data, Discord inbound
+    // reaches it through the same `handleInbound` every channel uses, and a
+    // Discord user id canonicalizes as opaque, which is what it is.
+    supportsVerification: true,
+    setupMessages: {
+      guardian:
+        "I'd like to verify my identity as your guardian on Discord. Can you help me set that up?",
+      contact:
+        "I'd like to verify a contact's Discord identity. Can you walk me through it?",
+    },
+  },
   phone: {
     id: "phone",
     label: "Phone Calling",

package/src/cli/commands/__tests__/conversations-slack.test.ts

@@ -112,7 +112,7 @@ mock.module("../../../messaging/providers/slack/send.js", () => ({
   },
   sendSlackStreamOp: async () => ({ ok: true, ts: "1700000000.000200" }),
   sendSlackReaction: async () => {},
-  sendSlackAssistantThreadStatus: async () => {},
+  sendSlackAgentSessionStatus: async () => {},
   sendSlackAttachments: async () => ({
     allFailed: false,
     failureCount: 0,

package/src/cli/commands/__tests__/inference-profiles.test.ts

@@ -11,6 +11,7 @@ import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 import { Command } from "commander";
 
 let lastIpcCall: { method: string; params?: any } | null = null;
+let ipcCalls: { method: string; params?: any }[] = [];
 let mockIpcResult: { ok: boolean; result?: unknown; error?: string } = {
   ok: true,
   result: {},
@@ -19,6 +20,7 @@ let mockIpcResult: { ok: boolean; result?: unknown; error?: string } = {
 mock.module("../../../ipc/cli-client.js", () => ({
   cliIpcCall: async (method: string, params?: Record<string, unknown>) => {
     lastIpcCall = { method, params };
+    ipcCalls.push({ method, params });
     return mockIpcResult;
   },
 }));
@@ -36,6 +38,7 @@ const { inferenceHelp } = await import("../inference.help.js");
 
 beforeEach(() => {
   lastIpcCall = null;
+  ipcCalls = [];
   mockIpcResult = { ok: true, result: {} };
   process.exitCode = 0;
 });
@@ -136,8 +139,13 @@ describe("profiles create", () => {
       "--allow-unlisted",
       "--allow-unavailable",
     ]);
-    expect(lastIpcCall?.method).toBe("inference_profiles_create");
-    expect(lastIpcCall?.params?.body).toEqual({
+    const createCall = ipcCalls.find(
+      (c) => c.method === "inference_profiles_create",
+    );
+    expect(createCall).toBeDefined();
+    // The save is followed by the advisory probe call.
+    expect(ipcCalls.at(-1)?.method).toBe("inference_profiles_validate");
+    expect(createCall?.params?.body).toEqual({
       name: "p",
       provider: "anthropic",
       model: "claude-opus-4-8",
@@ -243,11 +251,15 @@ describe("profiles update", () => {
       result: { ok: true, name: "p", entry: {}, warnings: [] },
     };
     await run(["profiles", "update", "p", "--effort", "low"]);
-    expect(lastIpcCall?.method).toBe("inference_profiles_update");
-    expect(lastIpcCall?.params).toEqual({
+    const updateCall = ipcCalls.find(
+      (c) => c.method === "inference_profiles_update",
+    );
+    expect(updateCall?.params).toEqual({
       pathParams: { name: "p" },
       body: { effort: "low" },
     });
+    // The save is followed by the advisory probe call.
+    expect(ipcCalls.at(-1)?.method).toBe("inference_profiles_validate");
   });
 
   test("refuses an empty update", async () => {

package/src/cli/commands/__tests__/inference-providers.test.ts

@@ -11,6 +11,8 @@ import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 import { Command } from "commander";
 
 let ipcCalls: { method: string; params?: any }[] = [];
+let openedUrls: string[] = [];
+let storedSecrets: Array<{ key: string; value: string }> = [];
 let mockIpcResult: { ok: boolean; result?: unknown; error?: string } = {
   ok: true,
   result: {},
@@ -30,6 +32,35 @@ mock.module("../../../util/logger.js", () => ({
     new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
 }));
 
+mock.module("../../lib/open-browser.js", () => ({
+  openInHostBrowser: (url: string) => {
+    openedUrls.push(url);
+  },
+}));
+
+mock.module("../../../security/oauth2.js", () => ({
+  startOAuth2Flow: async (
+    _config: unknown,
+    callbacks: { openUrl: (url: string) => void },
+  ) => {
+    callbacks.openUrl("https://auth.openai.com/oauth/authorize?state=test");
+    return {
+      tokens: {
+        accessToken: "test-access-token",
+        refreshToken: "test-refresh-token",
+        expiresIn: 3600,
+      },
+    };
+  },
+}));
+
+mock.module("../../../security/secure-keys.js", () => ({
+  setSecureKeyAsync: async (key: string, value: string) => {
+    storedSecrets.push({ key, value });
+    return true;
+  },
+}));
+
 const { attachProvidersSubcommand } = await import("../inference-providers.js");
 const { applyCommandHelp } = await import("../../lib/cli-command-help.js");
 const { inferenceHelp } = await import("../inference.help.js");
@@ -48,6 +79,8 @@ function lastIpcCall(): { method: string; params?: any } | null {
 
 beforeEach(() => {
   ipcCalls = [];
+  openedUrls = [];
+  storedSecrets = [];
   mockIpcResult = { ok: true, result: CONNECTION_RESULT };
   process.exitCode = 0;
 });
@@ -58,13 +91,19 @@ afterEach(() => {
 
 async function run(
   args: string[],
-): Promise<{ stdout: string; exitCode: number }> {
+): Promise<{ stdout: string; stderr: string; exitCode: number }> {
   const originalWrite = process.stdout.write.bind(process.stdout);
+  const originalErrorWrite = process.stderr.write.bind(process.stderr);
   const chunks: string[] = [];
+  const errorChunks: string[] = [];
   process.stdout.write = ((chunk: unknown) => {
     chunks.push(typeof chunk === "string" ? chunk : String(chunk));
     return true;
   }) as typeof process.stdout.write;
+  process.stderr.write = ((chunk: unknown) => {
+    errorChunks.push(typeof chunk === "string" ? chunk : String(chunk));
+    return true;
+  }) as typeof process.stderr.write;
 
   const prevExit = process.exitCode;
   process.exitCode = 0;
@@ -79,11 +118,13 @@ async function run(
     // swallow commander exits
   } finally {
     process.stdout.write = originalWrite;
+    process.stderr.write = originalErrorWrite;
   }
   const stdout = chunks.join("");
+  const stderr = errorChunks.join("");
   const exitCode = (process.exitCode as number) ?? 0;
   process.exitCode = prevExit;
-  return { stdout, exitCode };
+  return { stdout, stderr, exitCode };
 }
 
 describe("providers create — derived auth", () => {
@@ -484,3 +525,27 @@ describe("deprecated providers connections alias", () => {
     expect(stdout).toContain("No providers found.");
   });
 });
+
+describe("providers login-chatgpt", () => {
+  test("delivers the authorization URL through the browser helper and stderr", async () => {
+    const { stdout, stderr, exitCode } = await run([
+      "providers",
+      "login-chatgpt",
+      "--json",
+    ]);
+
+    expect(exitCode).toBe(0);
+    expect(JSON.parse(stdout)).toMatchObject({ ok: true });
+    expect(stderr).toContain(
+      "https://auth.openai.com/oauth/authorize?state=test",
+    );
+    expect(openedUrls).toEqual([
+      "https://auth.openai.com/oauth/authorize?state=test",
+    ]);
+    expect(storedSecrets).toContainEqual({
+      key: "credential/chatgpt/access_token",
+      value: "test-access-token",
+    });
+    expect(lastIpcCall()?.method).toBe("inference_provider_connections_update");
+  });
+});

package/src/cli/commands/channels/__tests__/channels.test.ts

@@ -91,6 +91,91 @@ describe("assistant channels", () => {
     });
   });
 
+  describe("two-axis rendering", () => {
+    /**
+     * A configured channel whose delivery stopped is the state this command
+     * used to have no word for. Setup is finished, so telling the reader to
+     * finish setup sends them to re-enter credentials that are already
+     * correct, and the operational reason for the outage is the only thing
+     * they can act on.
+     */
+    const configuredButDown = (health: string) =>
+      emptySnapshot("slack", {
+        ready: false,
+        setupStatus: "ready",
+        health,
+        localChecks: [
+          {
+            name: "inbound_delivery",
+            passed: health !== "failing",
+            kind: "operational",
+            message: "Slack Socket Mode holds no live connection",
+          },
+        ],
+      });
+
+    test("list calls a configured channel that stopped delivering down, not unfinished", async () => {
+      mockResponses = [
+        {
+          ok: true,
+          result: { success: true, snapshots: [configuredButDown("failing")] },
+        },
+      ];
+      const out = await runCli("channels", "list");
+      expect(out).toContain("not delivering");
+      expect(out).not.toContain("incomplete");
+      expect(out).not.toContain("not configured");
+    });
+
+    test("list distinguishes a verdict it could not obtain from an outage", async () => {
+      mockResponses = [
+        {
+          ok: true,
+          result: { success: true, snapshots: [configuredButDown("unknown")] },
+        },
+      ];
+      const out = await runCli("channels", "list");
+      expect(out).toContain("state unknown");
+      expect(out).not.toContain("not delivering");
+      expect(out).not.toContain("incomplete");
+    });
+
+    test("setup that genuinely did not finish still reads incomplete", async () => {
+      // The sensitivity check on the two above: the word has to survive for
+      // the state it was always correct for.
+      mockResponses = [
+        {
+          ok: true,
+          result: {
+            success: true,
+            snapshots: [
+              emptySnapshot("slack", {
+                ready: false,
+                setupStatus: "incomplete",
+              }),
+            ],
+          },
+        },
+      ];
+      const out = await runCli("channels", "list");
+      expect(out).toContain("incomplete");
+    });
+
+    test("the detail header agrees with its own glyph", async () => {
+      // It used to print the raw setupStatus beside a glyph derived from both
+      // axes, so an outage rendered as a warning sign next to the word ready.
+      mockResponses = [
+        {
+          ok: true,
+          result: { success: true, snapshots: [configuredButDown("failing")] },
+        },
+      ];
+      const out = await runCli("channels", "get", "slack");
+      expect(out).toContain("slack — not delivering");
+      expect(out).not.toContain("slack — ready");
+    });
+  });
+
   describe("get", () => {
     test("always re-probes via the refresh route (live, never cached)", async () => {
       mockResponses = [