@jami-studio/dispatch 0.13.14

package/src/server/lib/thread-link-preview.spec.ts

@@ -0,0 +1,127 @@
+import type { ChatThread } from "@agent-native/core/server";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const getRequestContextMock = vi.hoisted(() => vi.fn());
+const getThreadMock = vi.hoisted(() => vi.fn());
+
+vi.mock("@agent-native/core/server", () => ({
+  getRequestContext: getRequestContextMock,
+  getThread: getThreadMock,
+}));
+
+import { extractThreadPreviewImageUrl } from "../../lib/thread-link-preview";
+import { loadThreadLinkPreview } from "./thread-link-preview";
+
+function threadDataWithResult(toolName: string, result: unknown) {
+  return JSON.stringify({
+    messages: [
+      {
+        message: {
+          role: "assistant",
+          content: [
+            {
+              type: "tool-call",
+              toolName,
+              result:
+                typeof result === "string" ? result : JSON.stringify(result),
+            },
+          ],
+        },
+        parentId: null,
+      },
+    ],
+  });
+}
+
+function previewThread(overrides: Partial<ChatThread> = {}): ChatThread {
+  return {
+    id: "thread-1",
+    ownerEmail: "owner@example.test",
+    title: "Launch image",
+    preview: "Generated a launch image",
+    threadData: threadDataWithResult("generate-image", {
+      previewUrl: "https://cdn.example.com/generated-social.webp",
+    }),
+    messageCount: 1,
+    createdAt: 1,
+    updatedAt: 2,
+    scope: null,
+    pinnedAt: null,
+    archivedAt: null,
+    ...overrides,
+  };
+}
+
+beforeEach(() => {
+  getRequestContextMock.mockReset();
+  getThreadMock.mockReset();
+});
+
+describe("thread link preview image extraction", () => {
+  it("uses generated image preview URLs from generate-image results", () => {
+    expect(
+      extractThreadPreviewImageUrl(
+        threadDataWithResult("generate-image", {
+          url: "https://app.example.com/assets/asset/asset-1",
+          previewUrl: "https://cdn.example.com/generated-social.webp",
+          thumbnailUrl: "https://cdn.example.com/generated-social-thumb.webp",
+        }),
+      ),
+    ).toBe("https://cdn.example.com/generated-social.webp");
+  });
+
+  it("uses the newest image from batched generation results", () => {
+    expect(
+      extractThreadPreviewImageUrl(
+        threadDataWithResult("generate-image-batch", {
+          images: [
+            { previewUrl: "https://cdn.example.com/first.png" },
+            { previewUrl: "https://cdn.example.com/latest.png" },
+          ],
+        }),
+      ),
+    ).toBe("https://cdn.example.com/latest.png");
+  });
+
+  it("ignores asset page URLs that are not image media", () => {
+    expect(
+      extractThreadPreviewImageUrl(
+        threadDataWithResult("generate-image", {
+          url: "https://app.example.com/assets/asset/asset-1",
+        }),
+      ),
+    ).toBeNull();
+  });
+});
+
+describe("thread link preview access", () => {
+  it("loads preview metadata for the owning user", async () => {
+    getRequestContextMock.mockReturnValue({
+      userEmail: "owner@example.test",
+    });
+    getThreadMock.mockResolvedValue(previewThread());
+
+    await expect(loadThreadLinkPreview(" thread-1 ")).resolves.toEqual({
+      title: "Launch image",
+      description: "Generated a launch image",
+      imageUrl: "https://cdn.example.com/generated-social.webp",
+    });
+    expect(getThreadMock).toHaveBeenCalledWith("thread-1");
+  });
+
+  it("does not read thread metadata without an authenticated request context", async () => {
+    getRequestContextMock.mockReturnValue(undefined);
+
+    await expect(loadThreadLinkPreview("thread-1")).resolves.toBeNull();
+    expect(getThreadMock).not.toHaveBeenCalled();
+  });
+
+  it("does not emit another user's thread metadata", async () => {
+    getRequestContextMock.mockReturnValue({
+      userEmail: "viewer@example.test",
+    });
+    getThreadMock.mockResolvedValue(previewThread());
+
+    await expect(loadThreadLinkPreview("thread-1")).resolves.toBeNull();
+  });
+});

package/src/server/lib/thread-link-preview.ts

@@ -0,0 +1,32 @@
+import type { ChatThread } from "@agent-native/core/server";
+
+import {
+  extractThreadPreviewImageUrl,
+  type ThreadLinkPreview,
+} from "../../lib/thread-link-preview";
+
+function previewDescription(thread: ChatThread): string {
+  const preview = thread.preview.trim();
+  if (preview) return preview.slice(0, 180);
+  return "Open this Agent-Native thread in Dispatch.";
+}
+
+export async function loadThreadLinkPreview(
+  threadId: string | null | undefined,
+): Promise<ThreadLinkPreview | null> {
+  const id = threadId?.trim();
+  if (!id) return null;
+  const { getRequestContext, getThread } =
+    await import("@agent-native/core/server");
+  const viewerEmail = getRequestContext()?.userEmail?.trim();
+  if (!viewerEmail) return null;
+  const thread = await getThread(id).catch(() => null);
+  if (!thread) return null;
+  if (thread.ownerEmail !== viewerEmail) return null;
+  const title = thread.title.trim() || "Agent-Native thread";
+  return {
+    title,
+    description: previewDescription(thread),
+    imageUrl: extractThreadPreviewImageUrl(thread.threadData),
+  };
+}

package/src/server/lib/usage-metrics-store.spec.ts

@@ -0,0 +1,102 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+  detectEngineFromEnv: vi.fn(() => null),
+  detectEngineFromUserSecrets: vi.fn(async () => null),
+  execute: vi.fn(),
+  getSetting: vi.fn(async () => null),
+  getUsageSummary: vi.fn(),
+  listWorkspaceApps: vi.fn(),
+  registerBuiltinEngines: vi.fn(),
+}));
+
+vi.mock("@agent-native/core/agent/engine", () => ({
+  detectEngineFromEnv: (...args: any[]) => mocks.detectEngineFromEnv(...args),
+  detectEngineFromUserSecrets: (...args: any[]) =>
+    mocks.detectEngineFromUserSecrets(...args),
+  getAgentEngineEntry: vi.fn(() => null),
+  isAgentEngineSettingConfigured: vi.fn(() => false),
+  isStoredEngineUsable: vi.fn(() => false),
+  registerBuiltinEngines: () => mocks.registerBuiltinEngines(),
+}));
+
+vi.mock("@agent-native/core/db", () => ({
+  getDbExec: () => ({
+    execute: (...args: any[]) => mocks.execute(...args),
+  }),
+}));
+
+vi.mock("@agent-native/core/settings", () => ({
+  getSetting: (...args: any[]) => mocks.getSetting(...args),
+}));
+
+vi.mock("@agent-native/core/usage", () => ({
+  getUsageSummary: (...args: any[]) => mocks.getUsageSummary(...args),
+  usageBillingForEngine: () => ({
+    unit: "usd",
+    label: "Estimated spend",
+    shortLabel: "Cost",
+    source: "estimated-provider-cost",
+  }),
+}));
+
+vi.mock("./app-creation-store.js", () => ({
+  listWorkspaceApps: (...args: any[]) => mocks.listWorkspaceApps(...args),
+}));
+
+vi.mock("./dispatch-store.js", () => ({
+  currentOrgId: () => null,
+  currentOwnerEmail: () => "owner@example.test",
+}));
+
+const { listDispatchUsageMetrics } = await import("./usage-metrics-store.js");
+
+afterEach(() => {
+  vi.clearAllMocks();
+});
+
+describe("listDispatchUsageMetrics", () => {
+  it("returns empty metrics when usage storage bootstrap and reads fail", async () => {
+    mocks.getUsageSummary.mockRejectedValue(new Error("database is locked"));
+    mocks.execute.mockRejectedValue(new Error("no such table: token_usage"));
+    mocks.listWorkspaceApps.mockResolvedValue([
+      {
+        id: "dispatch",
+        name: "Dispatch",
+        path: "/dispatch",
+        status: "ready",
+        isDispatch: true,
+      },
+    ]);
+
+    const metrics = await listDispatchUsageMetrics({ sinceDays: 30 });
+
+    expect(mocks.getUsageSummary).toHaveBeenCalledWith({
+      ownerEmail: "__dispatch_metrics_init__",
+      sinceMs: expect.any(Number),
+    });
+    expect(metrics.access).toEqual({
+      viewerEmail: "owner@example.test",
+      orgId: null,
+      role: null,
+      scope: "solo",
+      totalUsers: 0,
+    });
+    expect(metrics.totals).toEqual({
+      costCents: 0,
+      calls: 0,
+      chatCalls: 0,
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheReadTokens: 0,
+      cacheWriteTokens: 0,
+      activeUsers: 0,
+      chatThreads: 0,
+      chatMessages: 0,
+      workspaceApps: 0,
+    });
+    expect(metrics.byUser).toEqual([]);
+    expect(metrics.recent).toEqual([]);
+    expect(metrics.appAccess).toHaveLength(1);
+  });
+});