@agent-native/dispatch 0.31.13 → 0.31.15

package/src/routes/pages/apps.tsx

@@ -18,7 +18,11 @@ import {
 } from "../../components/app-list-row";
 import { CreateAppPopover } from "../../components/create-app-popover";
 import { DispatchShell } from "../../components/dispatch-shell";
-import { OtherAppsSection } from "../../components/other-apps-section";
+import {
+  mergeOtherAppEntries,
+  otherAppEntryMatchesQuery,
+  OtherAppsSection,
+} from "../../components/other-apps-section";
 import { Button } from "../../components/ui/button";
 import {
   Collapsible,
@@ -92,6 +96,24 @@ function AppsRoute() {
   const activeApps = visibleApps.filter((app) => app.status !== "pending");
   const pendingApps = visibleApps.filter((app) => app.status === "pending");
   const archivedApps = allApps.filter((app) => app.archived);
+  const connectedApps =
+    (connectedAppsQuery.data as ConnectedAppSummary[] | undefined) ?? [];
+  const curatedTemplates = curatedTemplatesQuery.data as
+    | CuratedWorkspaceTemplatesResult
+    | undefined;
+  const otherAppEntries = mergeOtherAppEntries({
+    templates: curatedTemplates,
+    connectedApps,
+    workspaceApps: allApps,
+  });
+  const otherAppsSearchReady =
+    !connectedAppsQuery.isLoading && !curatedTemplatesQuery.isLoading;
+  const otherAppsMatchSearch =
+    !searchQuery.trim() ||
+    !otherAppsSearchReady ||
+    otherAppEntries.some((entry) =>
+      otherAppEntryMatchesQuery(entry, searchQuery),
+    );
   const orderedActiveApps = orderWorkspaceApps(activeApps, layout);
   const orderedPendingApps = orderWorkspaceApps(pendingApps, layout);
   const orderedArchivedApps = orderWorkspaceApps(archivedApps, layout);
@@ -107,7 +129,8 @@ function AppsRoute() {
   const hasSearchResults =
     filteredActiveApps.length > 0 ||
     filteredPendingApps.length > 0 ||
-    filteredArchivedApps.length > 0;
+    filteredArchivedApps.length > 0 ||
+    otherAppsMatchSearch;
   const showAppSkeletons = appsLoading && allApps.length === 0;
   const templateLabels: WorkspaceTemplateLabels = {
     appId: t("dispatch.pages.remixAppIdLabel"),
@@ -277,30 +300,23 @@ function AppsRoute() {
           </Collapsible>
         ) : null}
 
-        {!searchQuery.trim() ? (
-          <OtherAppsSection
-            templates={
-              curatedTemplatesQuery.data as
-                | CuratedWorkspaceTemplatesResult
-                | undefined
-            }
-            connectedApps={
-              connectedAppsQuery.data as ConnectedAppSummary[] | undefined
-            }
-            workspaceApps={allApps}
-            templatesLoading={curatedTemplatesQuery.isLoading}
-            connectedAppsLoading={connectedAppsQuery.isLoading}
-            templatesError={curatedTemplatesQuery.error}
-            connectedAppsError={connectedAppsQuery.error}
-            onRetryTemplates={() => void curatedTemplatesQuery.refetch()}
-            onRetryConnectedApps={() => void connectedAppsQuery.refetch()}
-            templateLabels={templateLabels}
-            onRemixSuccess={() => {
-              void appsQuery.refetch();
-              void curatedTemplatesQuery.refetch();
-            }}
-          />
-        ) : null}
+        <OtherAppsSection
+          templates={curatedTemplates}
+          connectedApps={connectedApps}
+          workspaceApps={allApps}
+          query={searchQuery}
+          templatesLoading={curatedTemplatesQuery.isLoading}
+          connectedAppsLoading={connectedAppsQuery.isLoading}
+          templatesError={curatedTemplatesQuery.error}
+          connectedAppsError={connectedAppsQuery.error}
+          onRetryTemplates={() => void curatedTemplatesQuery.refetch()}
+          onRetryConnectedApps={() => void connectedAppsQuery.refetch()}
+          templateLabels={templateLabels}
+          onRemixSuccess={() => {
+            void appsQuery.refetch();
+            void curatedTemplatesQuery.refetch();
+          }}
+        />
 
         {archivedApps.length > 0 &&
         (!searchQuery.trim() || filteredArchivedApps.length > 0) ? (

package/src/routes/pages/automations.spec.tsx

@@ -0,0 +1,240 @@
+// @vitest-environment happy-dom
+import { act, type ReactNode } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { MemoryRouter, useLocation, useNavigate } from "react-router";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { automationIdentity } from "../../lib/automation-display";
+import type { DispatchAutomationItem } from "../../lib/automations";
+import AutomationsRoute from "./automations";
+
+const automationA: DispatchAutomationItem = {
+  id: "auto-a",
+  name: "Nightly digest",
+  path: "jobs/nightly-digest.md",
+  owner: "user@example.com",
+  appId: "dispatch",
+  scope: "personal",
+  enabled: true,
+  triggerType: "schedule",
+  schedule: "0 6 * * *",
+  scheduleDescription: "Every day at 6am",
+  lastStatus: "success",
+};
+
+const automationB: DispatchAutomationItem = {
+  id: "auto-b",
+  name: "Error triage",
+  path: "jobs/error-triage.md",
+  owner: "user@example.com",
+  appId: "dispatch",
+  scope: "personal",
+  enabled: true,
+  triggerType: "event",
+  event: "issue.created",
+  lastStatus: "success",
+};
+
+// Real @tanstack/react-query is not exercised here — the route reads its
+// list straight from useQuery, so the hook itself is stubbed with a fixed
+// two-item list rather than standing up a QueryClient + network mock.
+vi.mock("@tanstack/react-query", () => ({
+  useQuery: ({ queryKey }: { queryKey: readonly unknown[] }) => {
+    if (String(queryKey[0]).includes("automations")) {
+      return {
+        data: [automationA, automationB],
+        isLoading: false,
+        isError: false,
+        error: null,
+      };
+    }
+    return { data: undefined, isLoading: false, isError: false, error: null };
+  },
+  useMutation: () => ({
+    mutate: vi.fn(),
+    isPending: false,
+    variables: undefined,
+  }),
+  useQueryClient: () => ({
+    cancelQueries: vi.fn(),
+    getQueriesData: vi.fn(() => []),
+    setQueriesData: vi.fn(),
+    invalidateQueries: vi.fn(),
+  }),
+}));
+
+vi.mock("@agent-native/core/client/hooks", () => ({
+  useChangeVersions: () => 0,
+}));
+
+vi.mock("@agent-native/core/client/agent-chat", () => ({
+  sendToAgentChat: vi.fn(),
+}));
+
+vi.mock("@agent-native/core/client/composer", () => ({
+  PromptComposer: () => null,
+}));
+
+vi.mock("../../components/dispatch-shell", () => ({
+  DispatchShell: ({ children }: { children: ReactNode }) => (
+    <main>{children}</main>
+  ),
+}));
+
+vi.mock("../../components/automation-details-panel", () => ({
+  AutomationDetailsPanel: ({
+    automation,
+  }: {
+    automation: DispatchAutomationItem;
+  }) => <div data-testid="details-panel">{automation.name}</div>,
+}));
+
+function LocationProbe() {
+  const location = useLocation();
+  return (
+    <div data-testid="location">{location.pathname + location.search}</div>
+  );
+}
+
+function GoBackProbe() {
+  const navigate = useNavigate();
+  return (
+    <button type="button" data-testid="go-back" onClick={() => navigate(-1)}>
+      Back
+    </button>
+  );
+}
+
+describe("AutomationsRoute", () => {
+  let container: HTMLDivElement;
+  let root: Root;
+
+  beforeEach(() => {
+    vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
+    container = document.createElement("div");
+    document.body.appendChild(container);
+    root = createRoot(container);
+  });
+
+  afterEach(() => {
+    act(() => root.unmount());
+    container.remove();
+    vi.unstubAllGlobals();
+  });
+
+  function locationText() {
+    return container.querySelector('[data-testid="location"]')?.textContent;
+  }
+
+  function findRowButton(name: string) {
+    return [...container.querySelectorAll("button")].find((button) =>
+      button.textContent?.includes(name),
+    );
+  }
+
+  it("writes the selected automation into the URL so it survives reload and back navigation", async () => {
+    await act(async () => {
+      root.render(
+        <MemoryRouter initialEntries={["/automations"]}>
+          <AutomationsRoute />
+          <LocationProbe />
+        </MemoryRouter>,
+      );
+    });
+
+    expect(locationText()).toBe("/automations");
+
+    const row = findRowButton(automationA.name);
+    expect(row).toBeTruthy();
+
+    await act(async () => {
+      row?.click();
+    });
+
+    expect(
+      container.querySelector('[data-testid="details-panel"]')?.textContent,
+    ).toBe(automationA.name);
+    // Selecting a row must push the identity into the address bar — a plain
+    // local-state selection leaves the URL unchanged, which is exactly the
+    // bug this test guards against (no way to link/reload/Back to a row).
+    expect(locationText()).toBe(
+      `/automations?automationId=${encodeURIComponent(automationIdentity(automationA))}`,
+    );
+
+    const otherRow = findRowButton(automationB.name);
+    await act(async () => {
+      otherRow?.click();
+    });
+
+    expect(locationText()).toBe(
+      `/automations?automationId=${encodeURIComponent(automationIdentity(automationB))}`,
+    );
+  });
+
+  it("pushes a history entry per row selection so Back steps through prior selections", async () => {
+    await act(async () => {
+      root.render(
+        <MemoryRouter initialEntries={["/automations"]}>
+          <AutomationsRoute />
+          <LocationProbe />
+          <GoBackProbe />
+        </MemoryRouter>,
+      );
+    });
+
+    const goBack = container.querySelector<HTMLButtonElement>(
+      '[data-testid="go-back"]',
+    );
+    expect(goBack).toBeTruthy();
+
+    await act(async () => {
+      findRowButton(automationA.name)?.click();
+    });
+    expect(locationText()).toBe(
+      `/automations?automationId=${encodeURIComponent(automationIdentity(automationA))}`,
+    );
+
+    await act(async () => {
+      findRowButton(automationB.name)?.click();
+    });
+    expect(locationText()).toBe(
+      `/automations?automationId=${encodeURIComponent(automationIdentity(automationB))}`,
+    );
+
+    // A row click is an explicit user selection, not URL canonicalization —
+    // it must push a new history entry so Back steps back through the prior
+    // selection (A) instead of skipping past the whole page's history in one
+    // jump. Replacing on every click (the bug this guards against) collapses
+    // all selections into a single entry.
+    await act(async () => {
+      goBack?.click();
+    });
+    expect(locationText()).toBe(
+      `/automations?automationId=${encodeURIComponent(automationIdentity(automationA))}`,
+    );
+
+    await act(async () => {
+      goBack?.click();
+    });
+    expect(locationText()).toBe("/automations");
+  });
+
+  it("reopens the matching detail panel when automationId is already in the URL", async () => {
+    const targetId = automationIdentity(automationB);
+    await act(async () => {
+      root.render(
+        <MemoryRouter
+          initialEntries={[
+            `/automations?automationId=${encodeURIComponent(targetId)}`,
+          ]}
+        >
+          <AutomationsRoute />
+        </MemoryRouter>,
+      );
+    });
+
+    expect(
+      container.querySelector('[data-testid="details-panel"]')?.textContent,
+    ).toBe(automationB.name);
+  });
+});

package/src/routes/pages/automations.tsx

@@ -9,8 +9,8 @@ import {
   IconSettingsAutomation,
 } from "@tabler/icons-react";
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
-import { useEffect, useMemo, useState } from "react";
-import { Link } from "react-router";
+import { useMemo, useState } from "react";
+import { Link, useSearchParams } from "react-router";
 import { toast } from "sonner";
 
 import { AutomationDetailsPanel } from "../../components/automation-details-panel";
@@ -189,10 +189,9 @@ function CreateAutomationButton() {
 }
 
 export default function AutomationsRoute() {
+  const [searchParams, setSearchParams] = useSearchParams();
   const [view, setView] = useState<"dispatch" | "all">("dispatch");
   const [query, setQuery] = useState("");
-  const [detailsTarget, setDetailsTarget] =
-    useState<DispatchAutomationItem | null>(null);
   const automationsQuery = useAutomations();
   const toggleAutomation = useToggleAutomation();
   const automations = automationsQuery.data ?? [];
@@ -238,17 +237,24 @@ export default function AutomationsRoute() {
       : null
     : null;
 
-  useEffect(() => {
-    if (!detailsTarget) return;
-    const current = filtered.find(
-      (item) => automationIdentity(item) === automationIdentity(detailsTarget),
-    );
-    if (current) {
-      if (current !== detailsTarget) setDetailsTarget(current);
-    } else {
-      setDetailsTarget(null);
-    }
-  }, [detailsTarget, filtered]);
+  // URL-backed selection (mirrors dreams.tsx's `?dreamId=`): the currently
+  // open automation lives in `automationId` so it survives reload, Back, and
+  // sharing a link, instead of vanishing local state.
+  const selectedAutomationId = searchParams.get("automationId");
+  const detailsTarget = selectedAutomationId
+    ? (filtered.find(
+        (item) => automationIdentity(item) === selectedAutomationId,
+      ) ?? null)
+    : null;
+
+  function selectAutomation(item: DispatchAutomationItem) {
+    // Push, don't replace: each row click is an explicit selection the user
+    // should be able to Back out of one step at a time, not a URL
+    // canonicalization that should collapse into the current entry.
+    const next = new URLSearchParams(searchParams);
+    next.set("automationId", automationIdentity(item));
+    setSearchParams(next);
+  }
 
   return (
     <DispatchShell
@@ -334,7 +340,7 @@ export default function AutomationsRoute() {
                         type="button"
                         className="w-full min-w-0 cursor-pointer text-left outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 focus-visible:ring-offset-card"
                         aria-pressed={isSelected}
-                        onClick={() => setDetailsTarget(item)}
+                        onClick={() => selectAutomation(item)}
                       >
                         <div className="flex min-w-0 items-center gap-2">
                           <StatusDot tone={status.tone} />

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

@@ -33,6 +33,7 @@ vi.mock("@agent-native/core/settings", () => ({
 }));
 
 vi.mock("@agent-native/core/usage", () => ({
+  builderCreditsFromCostCents: (cents: number) => cents / 4,
   getUsageSummary: (...args: any[]) => mocks.getUsageSummary(...args),
   usageBillingForEngine: () => ({
     unit: "usd",
@@ -101,7 +102,7 @@ describe("listDispatchUsageMetrics", () => {
       orgId: null,
       role: null,
       scope: "solo",
-      totalUsers: 0,
+      totalUsers: 1,
     });
     expect(metrics.totals).toEqual({
       costCents: 0,
@@ -195,6 +196,35 @@ describe("listDispatchUsageMetrics", () => {
     ).toBe(true);
   });
 
+  it("keeps an unaffiliated workspace request scoped to the signed-in user", async () => {
+    mocks.getUsageSummary.mockResolvedValue(null);
+    mocks.listWorkspaceApps.mockResolvedValue([]);
+    mocks.execute.mockResolvedValue({ rows: [] });
+
+    const metrics = await listDispatchUsageMetrics({
+      sinceDays: 30,
+      scope: "workspace",
+    });
+
+    expect(metrics.access).toMatchObject({
+      viewerEmail: "owner@example.test",
+      orgId: null,
+      scope: "solo",
+      totalUsers: 1,
+    });
+    const scopedTokenQueries = mocks.execute.mock.calls
+      .map(([query]) => String((query as { sql?: string }).sql))
+      .filter(
+        (sql) => sql.includes("FROM token_usage") && sql.includes("WHERE"),
+      );
+    expect(scopedTokenQueries.length).toBeGreaterThan(0);
+    expect(
+      scopedTokenQueries.every((sql) =>
+        sql.includes("LOWER(owner_email) IN (?)"),
+      ),
+    ).toBe(true);
+  });
+
   it("filters workspace usage and prompts to a selected member", async () => {
     mocks.currentOrgId.mockReturnValue("org-a");
     mocks.currentOwnerEmail.mockReturnValue("owner@example.test");
@@ -237,4 +267,105 @@ describe("listDispatchUsageMetrics", () => {
       }),
     ).toBe(true);
   });
+
+  it("returns monthly credits and workspace app creation rows from shared tables", async () => {
+    const firstUsageAt = Date.UTC(2026, 6, 1, 12);
+    const secondUsageAt = Date.UTC(2026, 6, 15, 12);
+    const firstCreationAt = Date.UTC(2026, 6, 2, 12);
+    const secondCreationAt = Date.UTC(2026, 6, 20, 12);
+
+    mocks.currentOrgId.mockReturnValue("org-a");
+    mocks.currentOwnerEmail.mockReturnValue("owner@example.test");
+    mocks.getUsageSummary.mockResolvedValue(null);
+    mocks.listWorkspaceApps.mockResolvedValue([]);
+    mocks.execute.mockImplementation(async ({ sql }: { sql: string }) => {
+      if (sql.includes("SELECT role FROM org_members")) {
+        return { rows: [{ role: "owner" }] };
+      }
+      if (sql.includes("SELECT email, role, joined_at")) {
+        return {
+          rows: [
+            { email: "owner@example.test", role: "owner", joined_at: null },
+            { email: "member@example.test", role: "member", joined_at: null },
+          ],
+        };
+      }
+      if (
+        sql.includes("FROM token_usage") &&
+        sql.includes("ORDER BY created_at ASC")
+      ) {
+        return {
+          rows: [
+            {
+              created_at: firstUsageAt,
+              owner_email: "member@example.test",
+              label: "chat",
+              input_tokens: 10,
+              output_tokens: 20,
+              cache_read_tokens: 0,
+              cache_write_tokens: 0,
+              cost_cents_x100: 10000,
+            },
+            {
+              created_at: secondUsageAt,
+              owner_email: "member@example.test",
+              label: "tool",
+              input_tokens: 30,
+              output_tokens: 40,
+              cache_read_tokens: 5,
+              cache_write_tokens: 2,
+              cost_cents_x100: 20000,
+            },
+          ],
+        };
+      }
+      if (sql.includes("FROM dispatch_audit_events")) {
+        return {
+          rows: [
+            {
+              created_at: firstCreationAt,
+              owner_email: "member@example.test",
+              actor: "member@example.test",
+              target_id: "app-one",
+            },
+            {
+              created_at: secondCreationAt,
+              owner_email: "member@example.test",
+              actor: "member@example.test",
+              target_id: "app-two",
+            },
+          ],
+        };
+      }
+      return { rows: [] };
+    });
+
+    const metrics = await listDispatchUsageMetrics({
+      sinceDays: 365,
+      scope: "workspace",
+    });
+
+    expect(metrics.monthlyByUser).toEqual([
+      {
+        month: "2026-07",
+        ownerEmail: "member@example.test",
+        costCents: 300,
+        credits: 75,
+        calls: 2,
+        chatCalls: 1,
+        inputTokens: 40,
+        outputTokens: 60,
+        cacheReadTokens: 5,
+        cacheWriteTokens: 2,
+      },
+    ]);
+    expect(metrics.workspaceAppCreationsByUserMonth).toEqual([
+      {
+        month: "2026-07",
+        ownerEmail: "member@example.test",
+        count: 2,
+        appIds: ["app-one", "app-two"],
+      },
+    ]);
+  });
 });