@vellumai/assistant 0.9.0 → 0.9.1-staging.1

package/src/runtime/invite-redemption-service.ts

@@ -129,7 +129,7 @@ export function redeemInvite(params: {
     : undefined;
   const contactResult = findContactChannel({
     channelType: sourceChannel,
-    externalUserId: canonicalUserId,
+    address: canonicalUserId,
     externalChatId: externalChatId,
   });
   const existingChannel = contactResult?.channel ?? null;
@@ -359,7 +359,7 @@ export function redeemVoiceInviteCode(params: {
     callerExternalUserId;
   const voiceContactResult = findContactChannel({
     channelType: "phone",
-    externalUserId: canonicalCallerId,
+    address: canonicalCallerId,
   });
   const existingVoiceChannel = voiceContactResult?.channel ?? null;
   const voiceContact = voiceContactResult?.contact ?? null;
@@ -511,7 +511,7 @@ export function redeemInviteByCode(params: {
     : undefined;
   const contactResult = findContactChannel({
     channelType: sourceChannel,
-    externalUserId: canonicalUserId,
+    address: canonicalUserId,
     externalChatId: externalChatId,
   });
   const existingChannel = contactResult?.channel ?? null;

package/src/runtime/routes/__tests__/plugins-routes.test.ts

@@ -34,6 +34,12 @@
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import {
+  type DiffPluginDeps,
+  type DiffPluginOptions,
+  type PluginDiffResult,
+  PluginDiffUnavailableError,
+} from "../../../cli/lib/diff-plugin.js";
 import {
   type InspectPluginDeps,
   type InspectPluginOptions,
@@ -66,8 +72,10 @@ import {
   type UninstallPluginResult,
 } from "../../../cli/lib/uninstall-plugin.js";
 import {
+  PluginMergeBaselineError,
   PluginNotUpgradableError,
   type PluginUpgradeResult,
+  PluginUpgradeStrategyUnsupportedError,
   type UpgradePluginDeps,
   type UpgradePluginOptions,
 } from "../../../cli/lib/upgrade-plugin.js";
@@ -173,10 +181,29 @@ const upgradeSpy = mock(
 );
 
 mock.module("../../../cli/lib/upgrade-plugin.js", () => ({
+  PluginMergeBaselineError,
   PluginNotUpgradableError,
+  PluginUpgradeStrategyUnsupportedError,
   upgradePlugin: upgradeSpy,
 }));
 
+// Mock diffPlugin: the lib re-materializes the install commit and computes the
+// per-file unified diff (covered by diff-plugin.test.ts); the route forwards
+// the name and maps the lib's error taxonomy to HTTP status codes.
+const diffSpy = mock(
+  async (
+    _opts: DiffPluginOptions,
+    _deps: DiffPluginDeps,
+  ): Promise<PluginDiffResult> => {
+    throw new Error("diffSpy default impl not configured");
+  },
+);
+
+mock.module("../../../cli/lib/diff-plugin.js", () => ({
+  PluginDiffUnavailableError,
+  diffPlugin: diffSpy,
+}));
+
 import {
   BadRequestError,
   ConflictError,
@@ -200,6 +227,7 @@ const getHandler = findHandler("plugins_get");
 const installHandler = findHandler("plugins_install");
 const inspectHandler = findHandler("plugins_inspect");
 const upgradeHandler = findHandler("plugins_upgrade");
+const diffHandler = findHandler("plugins_diff");
 
 function invoke(args: RouteHandlerArgs = {}): {
   plugins: Array<Record<string, unknown>>;
@@ -1080,6 +1108,7 @@ function upgradeResult(
     target: overrides.target ?? "/workspace/.vellum/plugins/level-up",
     fileCount: overrides.fileCount === undefined ? 12 : overrides.fileCount,
     dryRun: overrides.dryRun ?? false,
+    strategy: overrides.strategy ?? "overwrite",
     provenanceWasUnknown: overrides.provenanceWasUnknown ?? false,
   };
 }
@@ -1094,6 +1123,7 @@ async function invokeUpgrade(args: RouteHandlerArgs = {}): Promise<{
   target: string;
   fileCount: number | null;
   dryRun: boolean;
+  strategy: string;
   provenanceWasUnknown: boolean;
 }> {
   return (await upgradeHandler(args)) as {
@@ -1106,6 +1136,7 @@ async function invokeUpgrade(args: RouteHandlerArgs = {}): Promise<{
     target: string;
     fileCount: number | null;
     dryRun: boolean;
+    strategy: string;
     provenanceWasUnknown: boolean;
   };
 }
@@ -1136,13 +1167,69 @@ describe("POST /v1/plugins/:name/upgrade", () => {
       target: "/workspace/.vellum/plugins/level-up",
       fileCount: 12,
       dryRun: false,
+      strategy: "overwrite",
       provenanceWasUnknown: false,
     });
-    // AND the name + dryRun are forwarded to the lib
+    // AND the name + dryRun are forwarded to the lib (strategy omitted)
     expect(upgradeSpy.mock.calls[0]?.[0]).toEqual({
       name: "level-up",
       dryRun: false,
+      strategy: undefined,
+    });
+  });
+
+  test("forwards a requested strategy to the lib and projects it", async () => {
+    // GIVEN upgradePlugin merges local edits forward via the `ours` strategy
+    upgradeSpy.mockImplementation(async () =>
+      upgradeResult({ strategy: "ours" }),
+    );
+
+    // WHEN the handler runs with a strategy in the body
+    const result = await invokeUpgrade({
+      pathParams: { name: "level-up" },
+      body: { strategy: "ours" },
+    });
+
+    // THEN the strategy is forwarded to the lib and surfaced on the wire
+    expect(result.strategy).toBe("ours");
+    expect(upgradeSpy.mock.calls[0]?.[0]).toEqual({
+      name: "level-up",
+      dryRun: undefined,
+      strategy: "ours",
+    });
+  });
+
+  test("PluginUpgradeStrategyUnsupportedError \u2192 BadRequestError (400)", async () => {
+    // The `assistant` strategy is recognized but not yet implemented: a
+    // well-formed request the server cannot honor.
+    upgradeSpy.mockImplementation(async () => {
+      throw new PluginUpgradeStrategyUnsupportedError("assistant");
+    });
+
+    await expect(
+      invokeUpgrade({
+        pathParams: { name: "level-up" },
+        body: { strategy: "assistant" },
+      }),
+    ).rejects.toBeInstanceOf(BadRequestError);
+  });
+
+  test("PluginMergeBaselineError \u2192 ConflictError (409)", async () => {
+    // A merge strategy whose install-time baseline can't be reconstructed: a
+    // well-formed request that isn't actionable in the current state.
+    upgradeSpy.mockImplementation(async () => {
+      throw new PluginMergeBaselineError(
+        "level-up",
+        "the install-time baseline could not be faithfully reconstructed",
+      );
     });
+
+    await expect(
+      invokeUpgrade({
+        pathParams: { name: "level-up" },
+        body: { strategy: "ours" },
+      }),
+    ).rejects.toBeInstanceOf(ConflictError);
   });
 
   test("omits dryRun (passes undefined) when the body flag is absent", async () => {
@@ -1246,3 +1333,133 @@ describe("POST /v1/plugins/:name/upgrade", () => {
     expect((caught as Error).message).toContain("ECONNRESET");
   });
 });
+
+function diffResult(
+  overrides: Partial<PluginDiffResult> = {},
+): PluginDiffResult {
+  return {
+    name: overrides.name ?? "level-up",
+    target: overrides.target ?? "/workspace/.vellum/plugins/level-up",
+    commit: overrides.commit ?? "60a392b0000000000000000000000000000000aa",
+    committedAt: overrides.committedAt ?? "2026-06-01T12:34:56.000Z",
+    clean: overrides.clean ?? false,
+    files: overrides.files ?? [
+      {
+        path: "src/skill.ts",
+        status: "modified",
+        diff: "--- a/src/skill.ts\n+++ b/src/skill.ts\n@@ -1 +1 @@\n-old\n+new\n",
+        binary: false,
+        reconstructed: true,
+      },
+    ],
+  };
+}
+
+async function invokeDiff(
+  args: RouteHandlerArgs = {},
+): Promise<PluginDiffResult> {
+  return (await diffHandler(args)) as PluginDiffResult;
+}
+
+describe("POST /v1/plugins/:name/diff", () => {
+  beforeEach(() => {
+    diffSpy.mockReset();
+  });
+
+  test("forwards the name to diffPlugin and returns the diff verbatim", async () => {
+    // GIVEN diffPlugin reports a single modified file against the install commit
+    const view = diffResult();
+    diffSpy.mockImplementation(async () => view);
+
+    // WHEN the route handler is invoked with the path name
+    const result = await invokeDiff({ pathParams: { name: "level-up" } });
+
+    // THEN the diff is returned unchanged
+    expect(result).toEqual(view);
+    // AND only the name is forwarded to the lib (ref is never caller-supplied)
+    expect(diffSpy.mock.calls[0]?.[0]).toEqual({ name: "level-up" });
+  });
+
+  test("InvalidPluginNameError → BadRequestError (400)", async () => {
+    diffSpy.mockImplementation(async () => {
+      throw new InvalidPluginNameError("../escape");
+    });
+
+    await expect(
+      invokeDiff({ pathParams: { name: "../escape" } }),
+    ).rejects.toBeInstanceOf(BadRequestError);
+  });
+
+  test("PluginNotInstalledError → NotFoundError (404)", async () => {
+    diffSpy.mockImplementation(async () => {
+      throw new PluginNotInstalledError(
+        "ghost",
+        "/workspace/.vellum/plugins/ghost",
+      );
+    });
+
+    await expect(
+      invokeDiff({ pathParams: { name: "ghost" } }),
+    ).rejects.toBeInstanceOf(NotFoundError);
+  });
+
+  test("PluginNotFoundError → NotFoundError (404)", async () => {
+    // The recorded commit no longer resolves to a tree (source/commit gone).
+    diffSpy.mockImplementation(async () => {
+      throw new PluginNotFoundError(
+        "level-up",
+        "deadbeef",
+        "vellum-ai/level-up",
+      );
+    });
+
+    await expect(
+      invokeDiff({ pathParams: { name: "level-up" } }),
+    ).rejects.toBeInstanceOf(NotFoundError);
+  });
+
+  test("PluginDiffUnavailableError → ConflictError (409)", async () => {
+    // The install recorded no commit, so there is no baseline to diff against:
+    // a well-formed request that is not actionable in the current state.
+    diffSpy.mockImplementation(async () => {
+      throw new PluginDiffUnavailableError(
+        "level-up",
+        "no install commit was recorded",
+      );
+    });
+
+    await expect(
+      invokeDiff({ pathParams: { name: "level-up" } }),
+    ).rejects.toBeInstanceOf(ConflictError);
+  });
+
+  test("PluginSourceUnavailableError → ServiceUnavailableError (503)", async () => {
+    // Re-materializing the baseline can hit a rate-limited/down GitHub; that is
+    // retryable, so surface 503 rather than a misleading 500.
+    diffSpy.mockImplementation(async () => {
+      throw new PluginSourceUnavailableError(
+        "git clone failed for vellum-ai/level-up: HTTP 403",
+        503,
+      );
+    });
+
+    await expect(
+      invokeDiff({ pathParams: { name: "level-up" } }),
+    ).rejects.toBeInstanceOf(ServiceUnavailableError);
+  });
+
+  test("unknown errors → InternalError with original message preserved", async () => {
+    diffSpy.mockImplementation(async () => {
+      throw new Error("ECONNRESET");
+    });
+
+    let caught: unknown;
+    try {
+      await invokeDiff({ pathParams: { name: "level-up" } });
+    } catch (err) {
+      caught = err;
+    }
+    expect(caught).toBeInstanceOf(InternalError);
+    expect((caught as Error).message).toContain("ECONNRESET");
+  });
+});

package/src/runtime/routes/app-routes.ts

@@ -45,7 +45,7 @@ function loadDesignSystemCss(): string {
   try {
     const cssPath = join(
       import.meta.dirname ?? __dirname,
-      "../../../../clients/macos/vellum-assistant/Resources/vellum-design-system.css",
+      "assets/vellum-design-system.css",
     );
     designSystemCssCache = readFileSync(cssPath, "utf-8");
   } catch {

package/src/runtime/routes/approval-strategies/guardian-callback-strategy.ts

@@ -763,7 +763,7 @@ async function handleAccessRequestApproval(
   const requesterContactResult = approval.requesterExternalUserId
     ? findContactChannel({
         channelType: approval.channel,
-        externalUserId: approval.requesterExternalUserId,
+        address: approval.requesterExternalUserId,
       })
     : null;
   const requesterDisplayName =
@@ -772,7 +772,7 @@ async function handleAccessRequestApproval(
   const decidedByContactResult = decidedByExternalUserId
     ? findContactChannel({
         channelType: approval.channel,
-        externalUserId: decidedByExternalUserId,
+        address: decidedByExternalUserId,
       })
     : null;
   const decidedByDisplayName =