@vellumai/assistant 0.4.35 → 0.4.37

package/src/__tests__/trusted-contact-approval-notifier.test.ts

@@ -17,7 +17,10 @@ import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 const testDir = mkdtempSync(join(tmpdir(), "tc-approval-notifier-test-"));
 
 // ── Platform mock ──
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const realPlatform = require("../util/platform.js");
 mock.module("../util/platform.js", () => ({
+  ...realPlatform,
   getDataDir: () => testDir,
   isMacOS: () => process.platform === "darwin",
   isLinux: () => process.platform === "linux",
@@ -34,7 +37,10 @@ mock.module("../util/platform.js", () => ({
 }));
 
 // ── Logger mock ──
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const realLogger = require("../util/logger.js");
 mock.module("../util/logger.js", () => ({
+  ...realLogger,
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
       get: () => () => {},
@@ -130,9 +136,11 @@ mock.module("../config/env.js", () => ({
 }));
 
 // ── User reference mock ──
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const realUserReference = require("../config/user-reference.js");
 mock.module("../config/user-reference.js", () => ({
+  ...realUserReference,
   resolveUserReference: () => "my human",
-  DEFAULT_USER_REFERENCE: "my human",
   resolveGuardianName: (guardianDisplayName?: string | null): string => {
     // Mirror the real implementation: USER.md name > guardianDisplayName > default
     const userRef = "my human"; // In tests, resolveUserReference() returns this

package/src/__tests__/twitter-auth-handler.test.ts

@@ -79,9 +79,9 @@ mock.module("../security/secure-keys.js", () => ({
   deleteSecureKey: (account: string) => {
     if (account in secureKeyStore) {
       delete secureKeyStore[account];
-      return true;
+      return "deleted";
     }
-    return false;
+    return "not-found";
   },
   listSecureKeys: () => Object.keys(secureKeyStore),
   getBackendType: () => "encrypted",

package/src/__tests__/twitter-oauth-client.test.ts

@@ -10,7 +10,7 @@ mock.module("../security/secure-keys.js", () => ({
     secureKeyStore[account] = value;
     return true;
   },
-  deleteSecureKey: () => true,
+  deleteSecureKey: () => "deleted",
   listSecureKeys: () => Object.keys(secureKeyStore),
   getBackendType: () => "encrypted",
   isDowngradedFromKeychain: () => false,

package/src/__tests__/usage-routes.test.ts

@@ -0,0 +1,339 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+
+const testDir = mkdtempSync(join(tmpdir(), "usage-routes-test-"));
+
+mock.module("../util/platform.js", () => ({
+  getDataDir: () => testDir,
+  isMacOS: () => process.platform === "darwin",
+  isLinux: () => process.platform === "linux",
+  isWindows: () => process.platform === "win32",
+  getSocketPath: () => join(testDir, "test.sock"),
+  getPidPath: () => join(testDir, "test.pid"),
+  getDbPath: () => join(testDir, "test.db"),
+  getLogPath: () => join(testDir, "test.log"),
+  ensureDataDir: () => {},
+}));
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+import { getSqlite, initializeDb, resetDb } from "../memory/db.js";
+import { recordUsageEvent } from "../memory/llm-usage-store.js";
+import { usageRouteDefinitions } from "../runtime/routes/usage-routes.js";
+
+initializeDb();
+
+afterAll(() => {
+  resetDb();
+  try {
+    rmSync(testDir, { recursive: true });
+  } catch {
+    /* best effort */
+  }
+});
+
+function clearUsageEvents() {
+  getSqlite().run("DELETE FROM llm_usage_events");
+}
+
+// Build a simple dispatch helper from route definitions
+const routes = usageRouteDefinitions();
+
+function dispatch(method: string, path: string): Promise<Response> | Response {
+  const url = new URL(`http://localhost/v1/${path}`);
+  const req = new Request(url.toString(), { method });
+  const route = routes.find(
+    (r) =>
+      r.method === method &&
+      `usage/${url.pathname.split("/v1/usage/")[1]?.split("?")[0]}` ===
+        r.endpoint,
+  );
+  if (!route) throw new Error(`No route for ${method} /v1/${path}`);
+  return route.handler({
+    req,
+    url,
+    server: null as never,
+    authContext: {} as never,
+    params: {},
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Seed data helper
+// ---------------------------------------------------------------------------
+
+function seedEvents() {
+  const day1 = new Date("2025-01-15T10:00:00Z").getTime();
+  const day2 = new Date("2025-01-16T14:00:00Z").getTime();
+
+  // Two events on day 1, one on day 2
+  recordUsageEvent(
+    {
+      conversationId: "conv-1",
+      runId: "run-1",
+      requestId: "req-1",
+      actor: "main_agent",
+      provider: "anthropic",
+      model: "claude-sonnet-4-20250514",
+      inputTokens: 1000,
+      outputTokens: 200,
+      cacheCreationInputTokens: 50,
+      cacheReadInputTokens: 100,
+    },
+    { estimatedCostUsd: 0.005, pricingStatus: "priced" },
+  );
+  // Backdate the first event
+  getSqlite().run(
+    "UPDATE llm_usage_events SET created_at = ? WHERE request_id = 'req-1'",
+    [day1],
+  );
+
+  recordUsageEvent(
+    {
+      conversationId: "conv-1",
+      runId: "run-1",
+      requestId: "req-2",
+      actor: "context_compactor",
+      provider: "anthropic",
+      model: "claude-haiku-3",
+      inputTokens: 500,
+      outputTokens: 100,
+      cacheCreationInputTokens: 0,
+      cacheReadInputTokens: 0,
+    },
+    { estimatedCostUsd: 0.001, pricingStatus: "priced" },
+  );
+  getSqlite().run(
+    "UPDATE llm_usage_events SET created_at = ? WHERE request_id = 'req-2'",
+    [day1 + 3600_000],
+  );
+
+  recordUsageEvent(
+    {
+      conversationId: "conv-2",
+      runId: "run-2",
+      requestId: "req-3",
+      actor: "main_agent",
+      provider: "openai",
+      model: "gpt-4o",
+      inputTokens: 2000,
+      outputTokens: 400,
+      cacheCreationInputTokens: 0,
+      cacheReadInputTokens: 0,
+    },
+    { estimatedCostUsd: 0, pricingStatus: "unpriced" },
+  );
+  getSqlite().run(
+    "UPDATE llm_usage_events SET created_at = ? WHERE request_id = 'req-3'",
+    [day2],
+  );
+
+  return { day1, day2 };
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("usage routes", () => {
+  beforeEach(clearUsageEvents);
+
+  // -- query parsing / validation --
+
+  describe("query parameter validation", () => {
+    test("returns 400 when from/to are missing", async () => {
+      const res = await dispatch("GET", "usage/totals");
+      expect(res.status).toBe(400);
+      const body = (await res.json()) as { error: { message: string } };
+      expect(body.error.message).toContain("from");
+    });
+
+    test("returns 400 when from is missing", async () => {
+      const res = await dispatch("GET", "usage/totals?to=1000");
+      expect(res.status).toBe(400);
+    });
+
+    test("returns 400 when to is missing", async () => {
+      const res = await dispatch("GET", "usage/totals?from=1000");
+      expect(res.status).toBe(400);
+    });
+
+    test("returns 400 when from/to are not numbers", async () => {
+      const res = await dispatch("GET", "usage/totals?from=abc&to=def");
+      expect(res.status).toBe(400);
+      const body = (await res.json()) as { error: { message: string } };
+      expect(body.error.message).toContain("valid numbers");
+    });
+
+    test("returns 400 when from > to", async () => {
+      const res = await dispatch("GET", "usage/totals?from=2000&to=1000");
+      expect(res.status).toBe(400);
+      const body = (await res.json()) as { error: { message: string } };
+      expect(body.error.message).toContain("less than or equal");
+    });
+  });
+
+  // -- totals --
+
+  describe("GET /v1/usage/totals", () => {
+    test("returns zeros for empty range", async () => {
+      const res = await dispatch("GET", "usage/totals?from=0&to=999999999999");
+      expect(res.status).toBe(200);
+      const body = (await res.json()) as Record<string, number>;
+      expect(body.totalInputTokens).toBe(0);
+      expect(body.totalOutputTokens).toBe(0);
+      expect(body.totalEstimatedCostUsd).toBe(0);
+      expect(body.eventCount).toBe(0);
+    });
+
+    test("returns correct totals for seeded data", async () => {
+      const { day1, day2 } = seedEvents();
+      const from = day1 - 1000;
+      const to = day2 + 1000;
+
+      const res = await dispatch("GET", `usage/totals?from=${from}&to=${to}`);
+      expect(res.status).toBe(200);
+      const body = (await res.json()) as Record<string, number>;
+      expect(body.totalInputTokens).toBe(3500);
+      expect(body.totalOutputTokens).toBe(700);
+      expect(body.totalCacheCreationTokens).toBe(50);
+      expect(body.totalCacheReadTokens).toBe(100);
+      expect(body.eventCount).toBe(3);
+      expect(body.pricedEventCount).toBe(2);
+      expect(body.unpricedEventCount).toBe(1);
+    });
+
+    test("filters by time range", async () => {
+      const { day1 } = seedEvents();
+      // Only day 1 events
+      const from = day1 - 1000;
+      const to = day1 + 86400_000 - 1;
+
+      const res = await dispatch("GET", `usage/totals?from=${from}&to=${to}`);
+      const body = (await res.json()) as Record<string, number>;
+      expect(body.eventCount).toBe(2);
+      expect(body.totalInputTokens).toBe(1500);
+    });
+  });
+
+  // -- daily buckets --
+
+  describe("GET /v1/usage/daily", () => {
+    test("returns empty buckets array for empty range", async () => {
+      const res = await dispatch("GET", "usage/daily?from=0&to=999999999999");
+      expect(res.status).toBe(200);
+      const body = (await res.json()) as { buckets: unknown[] };
+      expect(body.buckets).toEqual([]);
+    });
+
+    test("returns daily buckets for seeded data", async () => {
+      const { day1, day2 } = seedEvents();
+      const from = day1 - 1000;
+      const to = day2 + 1000;
+
+      const res = await dispatch("GET", `usage/daily?from=${from}&to=${to}`);
+      expect(res.status).toBe(200);
+      const body = (await res.json()) as {
+        buckets: Array<{
+          date: string;
+          totalInputTokens: number;
+          eventCount: number;
+        }>;
+      };
+      expect(body.buckets).toHaveLength(2);
+      expect(body.buckets[0].date).toBe("2025-01-15");
+      expect(body.buckets[0].eventCount).toBe(2);
+      expect(body.buckets[1].date).toBe("2025-01-16");
+      expect(body.buckets[1].eventCount).toBe(1);
+    });
+  });
+
+  // -- breakdown --
+
+  describe("GET /v1/usage/breakdown", () => {
+    test("returns 400 when groupBy is missing", async () => {
+      const res = await dispatch(
+        "GET",
+        "usage/breakdown?from=0&to=999999999999",
+      );
+      expect(res.status).toBe(400);
+      const body = (await res.json()) as { error: { message: string } };
+      expect(body.error.message).toContain("groupBy");
+    });
+
+    test("returns 400 for invalid groupBy value", async () => {
+      const res = await dispatch(
+        "GET",
+        "usage/breakdown?from=0&to=999999999999&groupBy=invalid",
+      );
+      expect(res.status).toBe(400);
+      const body = (await res.json()) as { error: { message: string } };
+      expect(body.error.message).toContain("invalid");
+    });
+
+    test("groups by provider", async () => {
+      const { day1, day2 } = seedEvents();
+      const from = day1 - 1000;
+      const to = day2 + 1000;
+
+      const res = await dispatch(
+        "GET",
+        `usage/breakdown?from=${from}&to=${to}&groupBy=provider`,
+      );
+      expect(res.status).toBe(200);
+      const body = (await res.json()) as {
+        breakdown: Array<{
+          group: string;
+          totalInputTokens: number;
+          eventCount: number;
+        }>;
+      };
+      expect(body.breakdown).toHaveLength(2);
+      const groups = body.breakdown.map((b) => b.group).sort();
+      expect(groups).toEqual(["anthropic", "openai"]);
+    });
+
+    test("groups by actor", async () => {
+      const { day1, day2 } = seedEvents();
+      const from = day1 - 1000;
+      const to = day2 + 1000;
+
+      const res = await dispatch(
+        "GET",
+        `usage/breakdown?from=${from}&to=${to}&groupBy=actor`,
+      );
+      expect(res.status).toBe(200);
+      const body = (await res.json()) as {
+        breakdown: Array<{ group: string; eventCount: number }>;
+      };
+      expect(body.breakdown).toHaveLength(2);
+      const assistantGroup = body.breakdown.find(
+        (b) => b.group === "main_agent",
+      );
+      expect(assistantGroup?.eventCount).toBe(2);
+    });
+
+    test("groups by model", async () => {
+      const { day1, day2 } = seedEvents();
+      const from = day1 - 1000;
+      const to = day2 + 1000;
+
+      const res = await dispatch(
+        "GET",
+        `usage/breakdown?from=${from}&to=${to}&groupBy=model`,
+      );
+      expect(res.status).toBe(200);
+      const body = (await res.json()) as {
+        breakdown: Array<{ group: string; eventCount: number }>;
+      };
+      expect(body.breakdown).toHaveLength(3);
+    });
+  });
+});

package/src/__tests__/whatsapp-invite-adapter.test.ts

@@ -0,0 +1,94 @@
+/**
+ * Tests for the WhatsApp channel invite adapter.
+ *
+ * WhatsApp uses Meta WhatsApp Business API, not Twilio. The display phone
+ * number is resolved from workspace config (`whatsapp.phoneNumber`), falling
+ * back to undefined (triggering generic instructions) when not configured.
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Mocks — must be set up before importing the adapter
+// ---------------------------------------------------------------------------
+
+let mockWhatsAppPhoneNumber: string | undefined;
+let mockGetConfigThrows = false;
+
+mock.module("../config/loader.js", () => ({
+  loadRawConfig: () => ({}),
+  getConfig: () => {
+    if (mockGetConfigThrows) throw new Error("config not found");
+    return { whatsapp: { phoneNumber: mockWhatsAppPhoneNumber ?? "" } };
+  },
+  invalidateConfigCache: () => {},
+}));
+
+// ---------------------------------------------------------------------------
+// Import under test
+// ---------------------------------------------------------------------------
+
+import { whatsappInviteAdapter } from "../runtime/channel-invite-transports/whatsapp.js";
+import { resolveWhatsAppDisplayNumber } from "../runtime/channel-invite-transports/whatsapp.js";
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("whatsapp invite adapter", () => {
+  beforeEach(() => {
+    mockWhatsAppPhoneNumber = undefined;
+    mockGetConfigThrows = false;
+  });
+
+  test("adapter is registered for the whatsapp channel", () => {
+    expect(whatsappInviteAdapter.channel).toBe("whatsapp");
+  });
+
+  // -------------------------------------------------------------------------
+  // Handle resolution — configured path
+  // -------------------------------------------------------------------------
+
+  test("returns configured phone number from workspace config", () => {
+    mockWhatsAppPhoneNumber = "+15551234567";
+    const handle = whatsappInviteAdapter.resolveChannelHandle!();
+    expect(handle).toBe("+15551234567");
+  });
+
+  test("resolveWhatsAppDisplayNumber returns configured number", () => {
+    mockWhatsAppPhoneNumber = "+15559876543";
+    expect(resolveWhatsAppDisplayNumber()).toBe("+15559876543");
+  });
+
+  // -------------------------------------------------------------------------
+  // Handle resolution — unconfigured fallback
+  // -------------------------------------------------------------------------
+
+  test("returns undefined when whatsapp config is missing", () => {
+    const handle = whatsappInviteAdapter.resolveChannelHandle!();
+    expect(handle).toBeUndefined();
+  });
+
+  test("returns undefined when phoneNumber is empty string", () => {
+    mockWhatsAppPhoneNumber = "";
+    const handle = whatsappInviteAdapter.resolveChannelHandle!();
+    expect(handle).toBeUndefined();
+  });
+
+  test("returns undefined when config loading throws", () => {
+    mockGetConfigThrows = true;
+    const handle = whatsappInviteAdapter.resolveChannelHandle!();
+    expect(handle).toBeUndefined();
+  });
+
+  // -------------------------------------------------------------------------
+  // Adapter shape
+  // -------------------------------------------------------------------------
+
+  test("does not implement buildShareLink", () => {
+    expect(whatsappInviteAdapter.buildShareLink).toBeUndefined();
+  });
+
+  test("does not implement extractInboundToken", () => {
+    expect(whatsappInviteAdapter.extractInboundToken).toBeUndefined();
+  });
+});

package/src/agent/loop.ts

@@ -115,6 +115,7 @@ export class AgentLoop {
         name: string,
         input: Record<string, unknown>,
         onOutput?: (chunk: string) => void,
+        toolUseId?: string,
       ) => Promise<{
         content: string;
         isError: boolean;
@@ -140,6 +141,7 @@ export class AgentLoop {
       name: string,
       input: Record<string, unknown>,
       onOutput?: (chunk: string) => void,
+      toolUseId?: string,
     ) => Promise<{
       content: string;
       isError: boolean;
@@ -507,6 +509,7 @@ export class AgentLoop {
                   chunk,
                 });
               },
+              toolUse.id,
             );
 
             const toolDurationMs = Date.now() - toolStart;

package/src/amazon/checkout.ts

@@ -291,7 +291,6 @@ export async function getCheckoutSummary(): Promise<CheckoutSummary> {
 export async function placeOrder(
   opts: {
     paymentMethodId?: string;
-    deliverySlotId?: string;
   } = {},
 ): Promise<PlaceOrderResult> {
   const { tabId } = await prepareRequest();

package/src/approvals/guardian-request-resolvers.ts

@@ -19,6 +19,10 @@ import {
   getCanonicalGuardianRequest,
 } from "../memory/canonical-guardian-store.js";
 import { emitNotificationSignal } from "../notifications/emit-signal.js";
+import {
+  isNotificationSourceChannel,
+  type NotificationSourceChannel,
+} from "../notifications/signal.js";
 import { addRule } from "../permissions/trust-store.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
 import { mintDaemonDeliveryToken } from "../runtime/auth/token-service.js";
@@ -345,7 +349,11 @@ const accessRequestResolver: GuardianRequestResolver = {
 
   async resolve(ctx: ResolverContext): Promise<ResolverResult> {
     const { request, decision, channelDeliveryContext } = ctx;
-    const channel = request.sourceChannel ?? "unknown";
+    const channel: NotificationSourceChannel = isNotificationSourceChannel(
+      request.sourceChannel,
+    )
+      ? request.sourceChannel
+      : "vellum";
     const requesterExternalUserId = request.requesterExternalUserId ?? "";
     const requesterChatId =
       request.requesterChatId ?? request.requesterExternalUserId ?? "";

package/src/bundler/app-bundler.ts

@@ -1,12 +1,12 @@
 /**
- * Core packaging logic for .vellumapp zip archives.
+ * Core packaging logic for .vellum zip archives.
  *
  * Reads an app from the app-store, generates a manifest, and produces a
  * zip archive written to a temp file.
  */
 
-import { createHash, randomUUID } from "node:crypto";
-import { createWriteStream } from "node:fs";
+import { createHash } from "node:crypto";
+import { createWriteStream, existsSync, readFileSync } from "node:fs";
 import { readFile, stat, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { extname, join } from "node:path";
@@ -14,7 +14,7 @@ import { extname, join } from "node:path";
 import archiver from "archiver";
 import JSZip from "jszip";
 
-import { getApp } from "../memory/app-store.js";
+import { getApp, getAppsDir } from "../memory/app-store.js";
 import { computeContentId } from "../util/content-id.js";
 import { getLogger } from "../util/logger.js";
 import type { SigningCallback } from "./bundle-signer.js";
@@ -27,7 +27,6 @@ const bundlerLog = getLogger("app-bundler");
 import { APP_VERSION } from "../version.js";
 const PACKAGE_VERSION = APP_VERSION;
 
-const SHORT_HASH_LENGTH = 8;
 const HASH_DISPLAY_LENGTH = 12;
 const MAX_BUNDLE_SIZE_BYTES = 25 * 1024 * 1024; // 25 MB
 const ASSET_FETCH_TIMEOUT_MS = 10_000;
@@ -173,15 +172,17 @@ export async function materializeAssets(
 export interface BundleResult {
   bundlePath: string;
   manifest: AppManifest;
+  /** Base64-encoded PNG of the app icon, if one was generated. */
+  iconImageBase64?: string;
 }
 
 /**
- * Package an app into a .vellumapp zip archive.
+ * Package an app into a .vellum zip archive.
  *
  * @param appId - The ID of the app to package (from the app-store).
  * @param requestSignature - Optional callback to request an Ed25519 signature from the Swift client.
  *                           If provided, the bundle will be signed and include a signature.json.
- * @returns The path to the created .vellumapp file and the manifest.
+ * @returns The path to the created .vellum file and the manifest.
  * @throws If the app is not found, or the bundle exceeds the size limit.
  */
 export async function packageApp(
@@ -236,10 +237,12 @@ export async function packageApp(
   const allAssets = [...allAssetsMap.values()];
 
   // Create the zip archive
-  const bundleFilename = `${app.name.replace(
-    /[^a-zA-Z0-9_-]/g,
-    "_",
-  )}-${randomUUID().slice(0, SHORT_HASH_LENGTH)}.vellumapp`;
+  const safeName = app.name.replace(/[/\\:*?"<>|]/g, "_").trim() || "App";
+  const uniqueSuffix = createHash("sha256")
+    .update(`${appId}-${Date.now()}`)
+    .digest("hex")
+    .slice(0, 8);
+  const bundleFilename = `${safeName}-${uniqueSuffix}.vellum`;
   const bundlePath = join(tmpdir(), bundleFilename);
 
   await new Promise<void>((resolve, reject) => {
@@ -277,6 +280,12 @@ export async function packageApp(
       archive.append(asset.data, { name: asset.archivePath });
     }
 
+    // Include app icon if one was generated
+    const iconPath = join(getAppsDir(), appId, "icon.png");
+    if (existsSync(iconPath)) {
+      archive.append(readFileSync(iconPath), { name: "icon.png" });
+    }
+
     archive.finalize();
   });
 
@@ -318,5 +327,12 @@ export async function packageApp(
     );
   }
 
-  return { bundlePath, manifest };
+  // Read icon for inclusion in the response
+  let iconImageBase64: string | undefined;
+  const iconFilePath = join(getAppsDir(), appId, "icon.png");
+  if (existsSync(iconFilePath)) {
+    iconImageBase64 = readFileSync(iconFilePath).toString("base64");
+  }
+
+  return { bundlePath, manifest, iconImageBase64 };
 }

package/src/bundler/bundle-scanner.ts

@@ -1,5 +1,5 @@
 /**
- * BundleScanner — Security validation and static analysis for .vellumapp bundles.
+ * BundleScanner — Security validation and static analysis for .vellum bundles.
  *
  * Validates zip bundles before they are opened, returning structured results
  * with block-level (reject) and warn-level (flag) findings.

package/src/bundler/bundle-signer.ts

@@ -1,5 +1,5 @@
 /**
- * Bundle signing for .vellumapp archives.
+ * Bundle signing for .vellum archives.
  *
  * Computes content hashes, constructs a canonical signing payload,
  * and requests an Ed25519 signature from the Swift client via IPC.
@@ -78,9 +78,9 @@ async function computeContentHashes(
 }
 
 /**
- * Sign a .vellumapp bundle.
+ * Sign a .vellum bundle.
  *
- * @param bundlePath - Path to the .vellumapp zip archive.
+ * @param bundlePath - Path to the .vellum zip archive.
  * @param requestSignature - Callback to request a signature from the Swift client.
  * @returns The SignatureJson to embed in the archive.
  */

package/src/bundler/manifest.ts

@@ -1,5 +1,5 @@
 /**
- * Types and serialization for .vellumapp manifest files.
+ * Types and serialization for .vellum manifest files.
  */
 
 export interface AppManifest {