@startsimpli/ui 0.4.81 → 0.4.82

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@startsimpli/ui",
-  "version": "0.4.81",
+  "version": "0.4.82",
   "description": "Shared UI components package for StartSimpli applications",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -43,8 +43,8 @@
     "next": "^14.0.0 || ^15.0.0 || ^16.0.0",
     "react": "^18.0.0 || ^19.0.0",
     "react-dom": "^18.0.0 || ^19.0.0",
-    "@startsimpli/api": "^0.5.50",
-    "@startsimpli/auth": "^0.4.31"
+    "@startsimpli/auth": "^0.4.31",
+    "@startsimpli/api": "^0.5.51"
   },
   "peerDependenciesMeta": {
     "@startsimpli/api": {

package/src/components/activity/AccountActivityPanel.tsx

@@ -0,0 +1,55 @@
+'use client';
+
+/**
+ * AccountActivityPanel — the PLATFORM-SCOPE activity composer
+ * (startsim-768w.19.1.5).
+ *
+ * The same event stream as `ActivityFeedPanel` renders for one foundry, at the
+ * scope ABOVE any foundry: the rows that belong to no single one of them.
+ * Sign-ins are the whole population today — central auth mints tokens for every
+ * app, so a login is recorded once, for the person, with an empty tenant slug.
+ * A user with access to N foundries would otherwise get N duplicate rows or one
+ * arbitrarily-attributed one; the row is right, and it needed a reader with a
+ * scope of its own.
+ *
+ * DELIBERATELY ALMOST NOTHING. The paging, filtering, day grouping, infinite
+ * scroll and three empty states are `ActivityFeedPanel`'s, and the rendering is
+ * `ActivityTimeline`'s — both already built to render whatever the stream
+ * returns and to humanise an action they have never seen. What this adds is the
+ * COPY: an account-scope surface has to say why its rows name no foundry, and
+ * has to describe an empty page without claiming nothing happened, because the
+ * server answers a caller who may not read sign-ins with an empty page rather
+ * than a 403. Every prop stays overridable — a host that wants different words
+ * passes them, it does not fork the panel.
+ *
+ * The consuming app supplies `{ list: (p) => api.foundry.accountActivity(p) }`
+ * and its theme classNames. Nothing else — rule #9.
+ */
+import { ActivityFeedPanel, type ActivityFeedPanelProps } from './ActivityFeedPanel';
+
+/** Same props as the feed it composes: there is no account-only knob, and a
+ *  `slug` would be a lie — these events have no foundry. */
+export type AccountActivityPanelProps = ActivityFeedPanelProps;
+
+/** Cache namespace for the platform-scope stream. Deliberately NOT under a
+ *  foundry key, so invalidating one foundry never refetches it and vice versa. */
+export const ACCOUNT_ACTIVITY_QUERY_KEY = ['account', 'activity'] as const;
+
+export function AccountActivityPanel(props: AccountActivityPanelProps) {
+  return (
+    <ActivityFeedPanel
+      queryKey={ACCOUNT_ACTIVITY_QUERY_KEY}
+      title="Account activity"
+      description="Sign-ins across your account, newest first. These belong to the person rather than to one foundry, so they live here instead of on a foundry's own Activity tab."
+      // NOT "nothing has happened": an admin, member or viewer gets an empty
+      // page rather than a 403 (a 403 would confirm the rows exist), so copy
+      // that asserted the stream was empty would be wrong for most readers.
+      emptyTitle="No account activity to show"
+      emptyDescription="Sign-ins show up here. Sign-in history — who signed in, when and from where — is visible to foundry owners."
+      filteredEmptyTitle="No account activity matches these filters"
+      filteredEmptyDescription="Widen the date range or clear a filter to see more."
+      errorTitle="Could not load account activity"
+      {...props}
+    />
+  );
+}

package/src/components/activity/__tests__/account-activity.test.tsx

@@ -0,0 +1,153 @@
+/**
+ * startsim-768w.19.1.5 (RED) — the PLATFORM-SCOPE activity surface.
+ *
+ * `record_login()` writes a `member_login` row for every successful sign-in,
+ * with `tenant_slug=""` because a control-plane login belongs to the PERSON, not
+ * to one of the N foundries they can reach. The only reader was the per-foundry
+ * feed, which filters by slug — so the row was captured, permissioned and
+ * unreachable in every UI.
+ *
+ * THE SURFACE IS A CONSUMER, NOT A SECOND FEED. Everything here already exists:
+ * `ActivityFeedPanel` (paging, filters, day grouping, three empty states) over
+ * `ActivityTimeline` (the primitive), both built to render whatever the stream
+ * returns and to humanise an action they have never seen. The account scope
+ * differs by ONE thing — which client call it makes — plus the copy that says
+ * why these rows name no foundry. A second timeline here would be the bug.
+ */
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+import { render, screen, waitFor, within } from '@testing-library/react'
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+
+import {
+  AccountActivityPanel,
+  activityLabel,
+  activityTarget,
+  toActivityTimelineItems,
+  type ActivityEvent,
+  type ActivityPage,
+  type ActivityQuery,
+} from '../index'
+
+function login(over: Partial<ActivityEvent> & { id: string }): ActivityEvent {
+  return {
+    action: 'member_login',
+    type: 'member_login',
+    target_type: 'user',
+    target_id: '3f1c9e40-2b7a-4a11-9c33-8f0b2a5d61ee',
+    metadata: { app: 'foundry', method: 'credentials', user_agent: 'Firefox/141.0' },
+    actor: { id: 'u-1', email: 'ada@x.com', name: 'Ada Lovelace' },
+    actor_email: 'ada@x.com',
+    state: null,
+    previous_state: null,
+    source: '',
+    reason: '',
+    error: '',
+    run_id: '',
+    run_kind: '',
+    created_at: '2026-07-27T19:38:00Z',
+    ...over,
+  }
+}
+
+function page(results: ActivityEvent[], over: Partial<ActivityPage> = {}): ActivityPage {
+  return { count: results.length, next: null, previous: null, results, ...over }
+}
+
+function withQuery(ui: React.ReactElement) {
+  const qc = new QueryClient({ defaultOptions: { queries: { retry: false } } })
+  return render(<QueryClientProvider client={qc}>{ui}</QueryClientProvider>)
+}
+
+function timeline() {
+  return within(screen.getByTestId('activity-timeline'))
+}
+
+describe('AccountActivityPanel', () => {
+  it('renders a login the per-foundry feed could never reach', async () => {
+    const list = jest.fn(async () => page([login({ id: 'e1' })]))
+    withQuery(<AccountActivityPanel client={{ list }} />)
+
+    await waitFor(() => expect(timeline().getByText('Member login')).toBeInTheDocument())
+    expect(timeline().getByText('Ada Lovelace')).toBeInTheDocument()
+  })
+
+  it('says which app the sign-in was for', async () => {
+    const list = jest.fn(async () => page([login({ id: 'e2' })]))
+    withQuery(<AccountActivityPanel client={{ list }} />)
+
+    // `app` is the row's own descriptor for what it touched. Without it the
+    // target app is captured on the row and invisible on the page — the same
+    // shape of bug one level down.
+    await waitFor(() => expect(timeline().getByText('foundry')).toBeInTheDocument())
+  })
+
+  it('pages server-side (rule #8) rather than asking for everything', async () => {
+    const list = jest.fn(async (_p: ActivityQuery) => page([login({ id: 'e3' })]))
+    withQuery(<AccountActivityPanel client={{ list }} />)
+
+    await waitFor(() => expect(list).toHaveBeenCalled())
+    const params = list.mock.calls[0][0] as ActivityQuery
+    expect(params.page).toBe(1)
+    expect(typeof params.pageSize).toBe('number')
+  })
+
+  it('takes no slug — the events belong to no foundry', () => {
+    const list = jest.fn(async () => page([]))
+    // A slug prop would be a type error; the runtime check is that the panel
+    // renders from the injected client alone.
+    withQuery(<AccountActivityPanel client={{ list }} />)
+    expect(screen.getByTestId('activity-feed-panel')).toBeInTheDocument()
+  })
+
+  it('explains an empty page without claiming nothing happened', async () => {
+    const list = jest.fn(async () => page([]))
+    withQuery(<AccountActivityPanel client={{ list }} />)
+
+    // An admin/member/viewer gets an empty page rather than a 403, so the copy
+    // must not assert "no sign-ins have happened".
+    await screen.findByText(/no account activity/i)
+    const body = screen.getByTestId('activity-feed-panel').textContent ?? ''
+    expect(body).toMatch(/sign-in/i)
+    expect(body).toMatch(/owner/i)
+    expect(body).not.toMatch(/nothing recorded/i)
+  })
+
+  it('lets a host override the shared copy', async () => {
+    const list = jest.fn(async () => page([]))
+    withQuery(<AccountActivityPanel client={{ list }} title="Sign-in history" />)
+    await waitFor(() => expect(screen.getByText('Sign-in history')).toBeInTheDocument())
+  })
+})
+
+describe('the platform scope reuses the shared feed', () => {
+  it('humanises member_login with no new vocabulary', () => {
+    expect(activityLabel(login({ id: 'e4' }))).toBe('Member login')
+  })
+
+  it('renders the app instead of the opaque user id', () => {
+    expect(activityTarget(login({ id: 'e5' }))).toBe('foundry')
+    // No app on the row -> nothing, never the UUID.
+    expect(activityTarget(login({ id: 'e6', metadata: { method: 'sso' } }))).toBe('')
+  })
+
+  it('maps a login onto the same timeline item shape as any other row', () => {
+    const [item] = toActivityTimelineItems([login({ id: 'e7' })])
+    expect(item.title).toBe('Member login')
+    expect(item.actor?.email).toBe('ada@x.com')
+    expect(item.occurredAt).toBe('2026-07-27T19:38:00Z')
+  })
+
+  it('does not render its own list — it composes ActivityFeedPanel', () => {
+    const src = fs.readFileSync(
+      path.resolve(__dirname, '..', 'AccountActivityPanel.tsx'), 'utf8')
+    expect(src).toMatch(/<ActivityFeedPanel/)
+    // No list of its own, no second query, no second timeline. (The doc comment
+    // may NAME the timeline; what it may not do is import or render one.)
+    const banned = [/\.map\(/, /useInfiniteQuery/, /<ActivityTimeline/,
+                    /from '\.\.\/ActivityTimeline'/]
+    for (const re of banned) {
+      expect(`${re.source}:${re.test(src)}`).toBe(`${re.source}:false`)
+    }
+  })
+})

package/src/components/activity/activity-events.ts

@@ -132,6 +132,11 @@ const OPAQUE_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}
  */
 const TARGET_DESCRIPTORS = [
   'email', 'name', 'title', 'label', 'source', 'source_name',
+  // `app` is what a platform-scope row touched: a sign-in records which app it
+  // minted a token for, and its `target_id` is the actor's own UUID, so without
+  // this key the app is captured on the row and invisible on the page
+  // (startsim-768w.19.1.5). Same convention, not a login special case.
+  'app',
   'repo', 'slug', 'path', 'source_key', 'provider_key', 'credential_type',
 ];
 

package/src/components/activity/index.ts

@@ -12,6 +12,11 @@
  * never seen rather than dropping or mislabelling it.
  */
 export { ActivityFeedPanel, type ActivityFeedPanelProps } from './ActivityFeedPanel';
+export {
+  AccountActivityPanel,
+  ACCOUNT_ACTIVITY_QUERY_KEY,
+  type AccountActivityPanelProps,
+} from './AccountActivityPanel';
 export {
   ACTIVITY_FEED_PANEL_DEFAULTS,
   type ActivityFeedPanelClassNames,