@sixb/core 0.1.20 → 0.1.22

package/src/storage/auth/in-memory/users.ts

@@ -6,6 +6,7 @@ import type {
   ListAuthUsersInput,
   ListAuthUsersResult,
   UpdateAuthUserProfileInput,
+  UpdateAuthUserResult,
   UpdateAuthUserStatusInput,
   UserRecord,
 } from "../types"
@@ -69,6 +70,16 @@ export class InMemoryAuthUserStore implements AuthUserStore {
     return cloneOptionalRecord(record)
   }
 
+  async getByIds(params: {
+    readonly projectId: string
+    readonly ids: readonly string[]
+  }): Promise<readonly UserRecord[]> {
+    return [...new Set(params.ids)].flatMap((id) => {
+      const record = this.state.users.get(userKey(params.projectId, id))
+      return record ? [cloneRecord(record)] : []
+    })
+  }
+
   async getByEmail(params: {
     readonly projectId: string
     readonly email: string
@@ -76,7 +87,7 @@ export class InMemoryAuthUserStore implements AuthUserStore {
     return cloneOptionalRecord(getUserByEmail(this.state, params.projectId, params.email))
   }
 
-  async updateProfile(input: UpdateAuthUserProfileInput): Promise<UserRecord> {
+  async updateProfile(input: UpdateAuthUserProfileInput): Promise<UpdateAuthUserResult> {
     const key = userKey(input.projectId, input.id)
     const existing = this.state.users.get(key)
 
@@ -87,17 +98,23 @@ export class InMemoryAuthUserStore implements AuthUserStore {
       )
     }
 
+    const displayName = profileValue(input.displayName, existing.displayName)
+    const avatarUrl = profileValue(input.avatarUrl, existing.avatarUrl)
+    if (displayName === existing.displayName && avatarUrl === existing.avatarUrl) {
+      return { user: cloneRecord(existing), previousUser: cloneRecord(existing) }
+    }
+
     const next: UserRecord = {
       ...existing,
-      displayName: input.displayName,
-      avatarUrl: input.avatarUrl,
+      displayName,
+      avatarUrl,
       updatedAt: dateOrNow(input.updatedAt),
     }
     this.state.users.set(key, cloneRecord(next))
-    return cloneRecord(next)
+    return { user: cloneRecord(next), previousUser: cloneRecord(existing) }
   }
 
-  async updateStatus(input: UpdateAuthUserStatusInput): Promise<UserRecord> {
+  async updateStatus(input: UpdateAuthUserStatusInput): Promise<UpdateAuthUserResult> {
     const key = userKey(input.projectId, input.id)
     const existing = this.state.users.get(key)
 
@@ -114,7 +131,7 @@ export class InMemoryAuthUserStore implements AuthUserStore {
       updatedAt: dateOrNow(input.updatedAt),
     }
     this.state.users.set(key, cloneRecord(next))
-    return cloneRecord(next)
+    return { user: cloneRecord(next), previousUser: cloneRecord(existing) }
   }
 
   async list(input: ListAuthUsersInput): Promise<ListAuthUsersResult> {
@@ -123,10 +140,12 @@ export class InMemoryAuthUserStore implements AuthUserStore {
     }
 
     const statuses = input.statuses ? new Set(input.statuses) : null
+    const search = input.search?.toLowerCase()
     const order = input.order ?? "desc"
     const rows = [...this.state.users.values()]
       .filter((user) => user.projectId === input.projectId)
       .filter((user) => (statuses ? statuses.has(user.status) : true))
+      .filter((user) => (search === undefined ? true : userMatches(user, search)))
       .sort((a, b) => compareByCreatedAt(a, b, order))
 
     const page = paginate(rows, input)
@@ -137,3 +156,18 @@ export class InMemoryAuthUserStore implements AuthUserStore {
     }
   }
 }
+
+// Omitted keeps the current value, and `null` clears it.
+function profileValue(
+  value: string | null | undefined,
+  current: string | undefined
+): string | undefined {
+  return value === undefined ? current : (value ?? undefined)
+}
+
+function userMatches(user: UserRecord, search: string): boolean {
+  return (
+    (user.displayName?.toLowerCase().includes(search) ?? false) ||
+    user.email.toLowerCase().includes(search)
+  )
+}

package/src/storage/auth/index.ts

@@ -42,6 +42,8 @@ export type {
   ListAuthInvitationsResult,
   ListAuthServiceAccountsInput,
   ListAuthServiceAccountsResult,
+  ListAuthSessionsInput,
+  ListAuthSessionsResult,
   ListAuthUsersInput,
   ListAuthUsersResult,
   MagicLinkRecord,
@@ -55,6 +57,7 @@ export type {
   SuspendUserAndRevokeSessionsInput,
   UpdateAuthServiceAccountInput,
   UpdateAuthUserProfileInput,
+  UpdateAuthUserResult,
   UpdateAuthUserStatusInput,
   UpsertAuthGroupMembershipInput,
   UpsertAuthServiceAccountGroupMembershipInput,

package/src/storage/auth/types.ts

@@ -190,14 +190,21 @@ export interface CreateAuthUserInput {
   readonly updatedAt?: Date
 }
 
+/** Omitted fields stay unchanged, and `null` clears one. */
 export interface UpdateAuthUserProfileInput {
   readonly projectId: string
   readonly id: string
-  readonly displayName?: string
-  readonly avatarUrl?: string
+  readonly displayName?: string | null
+  readonly avatarUrl?: string | null
   readonly updatedAt?: Date
 }
 
+/** A change to one user, with the user as the change found them, read in the same atomic step. */
+export interface UpdateAuthUserResult {
+  readonly user: UserRecord
+  readonly previousUser: UserRecord
+}
+
 export interface UpdateAuthUserStatusInput {
   readonly projectId: string
   readonly id: string
@@ -208,6 +215,12 @@ export interface UpdateAuthUserStatusInput {
 export interface ListAuthUsersInput {
   readonly projectId: string
   readonly statuses?: readonly UserStatus[]
+  /**
+   * Keep users whose display name or email contains this text, ignoring case. Matched literally:
+   * `%` and `_` are plain characters. `total` and `hasMore` count only the matches. SQLite ignores
+   * case for ASCII letters only.
+   */
+  readonly search?: string
   readonly limit?: number
   readonly offset?: number
   readonly order?: "asc" | "desc"
@@ -324,6 +337,22 @@ export interface ListAuthAccessTokensResult {
   readonly total: number
 }
 
+export interface ListAuthSessionsInput {
+  readonly projectId: string
+  readonly userId: string
+  readonly limit: number
+  /**
+   * Continue a list: sessions created at or before `createdAt`, past the first `skip` of those
+   * created exactly then, which the previous pages returned.
+   */
+  readonly before?: { readonly createdAt: Date; readonly skip: number }
+}
+
+export interface ListAuthSessionsResult {
+  readonly sessions: readonly SessionRecord[]
+  readonly hasMore: boolean
+}
+
 export interface CompleteAuthSessionInput {
   readonly id: string
   readonly tokenHash: string
@@ -407,8 +436,11 @@ export interface CompleteDeviceAuthorizationInput {
   readonly projectId: string
   readonly id: string
   readonly deviceCodeHash: string
-  /** The bearer session to start for the approving user. */
-  readonly session: CreateAuthSessionInput & { readonly bearer: BearerSessionState }
+  /**
+   * The session to start for the approving user: a bearer session for a native client, or a
+   * cookie session for a browser that asked to be approved from another one.
+   */
+  readonly session: CreateAuthSessionInput
   readonly completedAt: Date
 }
 
@@ -441,6 +473,10 @@ export interface CompleteOidcSignInInput {
    * links the user who has this email, or claims this email's invitation for a new user.
    */
   readonly email: string
+  /**
+   * The name and picture the provider sends. Every sign-in sets them on the user, and one left out
+   * keeps the stored value. `updatedAt` moves only when one of them changes.
+   */
   readonly displayName?: string
   readonly avatarUrl?: string
   readonly claims?: Readonly<Record<string, unknown>>
@@ -462,6 +498,11 @@ export interface CompleteSignInResult {
   readonly identity?: UserIdentityRecord
   readonly invitation?: InvitationRecord
   readonly groupMemberships: readonly GroupMembershipRecord[]
+  /**
+   * The user as this sign-in found them, before it changed their profile, or `null` when this
+   * sign-in created them.
+   */
+  readonly previousUser: UserRecord | null
 }
 
 export interface SuspendUserAndRevokeSessionsInput {
@@ -473,12 +514,21 @@ export interface SuspendUserAndRevokeSessionsInput {
 export interface AuthUserStore {
   create(input: CreateAuthUserInput): Promise<UserRecord>
   getById(params: { readonly projectId: string; readonly id: string }): Promise<UserRecord | null>
+  /** The users of the project with these ids, in any order. Ids no user has are skipped. */
+  getByIds(params: {
+    readonly projectId: string
+    readonly ids: readonly string[]
+  }): Promise<readonly UserRecord[]>
   getByEmail(params: {
     readonly projectId: string
     readonly email: string
   }): Promise<UserRecord | null>
-  updateProfile(input: UpdateAuthUserProfileInput): Promise<UserRecord>
-  updateStatus(input: UpdateAuthUserStatusInput): Promise<UserRecord>
+  /**
+   * Update only the provided fields; omitted fields must remain unchanged atomically. When no
+   * value changes, nothing is written, so `updatedAt` stays as it was.
+   */
+  updateProfile(input: UpdateAuthUserProfileInput): Promise<UpdateAuthUserResult>
+  updateStatus(input: UpdateAuthUserStatusInput): Promise<UpdateAuthUserResult>
   list(input: ListAuthUsersInput): Promise<ListAuthUsersResult>
 }
 
@@ -536,6 +586,8 @@ export interface AuthSessionStore {
     readonly userId: string
     readonly now: Date
   }): Promise<readonly SessionRecord[]>
+  /** Every session of a user, revoked and expired ones too, newest first: a sign-in history. */
+  listByUserId(params: ListAuthSessionsInput): Promise<ListAuthSessionsResult>
   /** A live browser (cookie) session whose secret hashes to `tokenHash`. */
   findValidByTokenHash(params: {
     readonly projectId: string
@@ -745,5 +797,7 @@ export interface AuthStorage {
   completeDeviceAuthorization(
     input: CompleteDeviceAuthorizationInput
   ): Promise<CompleteDeviceAuthorizationResult>
-  suspendUserAndRevokeSessions(input: SuspendUserAndRevokeSessionsInput): Promise<UserRecord>
+  suspendUserAndRevokeSessions(
+    input: SuspendUserAndRevokeSessionsInput
+  ): Promise<UpdateAuthUserResult>
 }

package/src/storage/executions/in-memory.ts

@@ -1,7 +1,16 @@
 import type { AuthStorage } from "../auth"
 import type { ShareSessionStorage } from "../share-sessions"
 import { ExecutionStorageError } from "./errors"
-import type { CreateExecutionInput, ExecutionRecord, ExecutionStorage } from "./types"
+import { compareExecutionCreation } from "./provider"
+import type {
+  CreateExecutionInput,
+  ExecutionDescendant,
+  ExecutionRecord,
+  ExecutionStorage,
+  ListExecutionDescendantsInput,
+  ListSessionExecutionsInput,
+  SessionExecutions,
+} from "./types"
 import { cloneExecutionRecord, prepareExecutionRecord } from "./validation"
 
 type RunRootOperation = <T>(run: () => Promise<T> | T) => Promise<T>
@@ -73,6 +82,89 @@ export class InMemoryExecutionStorage implements ExecutionStorage {
       return record ? cloneExecutionRecord(record) : null
     })
   }
+
+  async listBySession(input: ListSessionExecutionsInput): Promise<SessionExecutions> {
+    return this.runRootOperation(() => {
+      const rows = [...this.rows.values()].filter((row) => row.projectId === input.projectId)
+
+      const roots = rows
+        .filter(
+          (row) =>
+            row.source.type !== "execution" &&
+            row.createdAt >= input.from &&
+            row.createdAt < input.to &&
+            isFromSession(row, input.session)
+        )
+        .sort(compareExecutionCreation)
+        .slice(0, input.limit + 1)
+
+      // Level by level, as the SQL providers walk the tree, so truncation keeps roots first.
+      const found = [...roots]
+      let level = roots
+      while (level.length > 0 && found.length <= input.limit) {
+        const parents = new Set(level.map((row) => row.id))
+        level = rows
+          .filter((row) => row.source.type === "execution" && parents.has(row.source.executionId))
+          .sort(compareExecutionCreation)
+        found.push(...level)
+      }
+
+      return {
+        executions: found
+          .slice(0, input.limit)
+          .sort(compareExecutionCreation)
+          .map(cloneExecutionRecord),
+        truncated: found.length > input.limit,
+      }
+    })
+  }
+
+  async listDescendants(
+    input: ListExecutionDescendantsInput
+  ): Promise<readonly ExecutionDescendant[]> {
+    return this.runRootOperation(() => {
+      const rows = [...this.rows.values()].filter((row) => row.projectId === input.projectId)
+      const seen = new Set(input.executionIds)
+      const found: ExecutionRecord[] = []
+
+      let parents = new Set(input.executionIds)
+      while (parents.size > 0) {
+        const level = rows.filter(
+          (row) =>
+            row.source.type === "execution" &&
+            parents.has(row.source.executionId) &&
+            !seen.has(row.id)
+        )
+
+        for (const row of level) seen.add(row.id)
+        found.push(...level)
+        parents = new Set(level.map((row) => row.id))
+      }
+
+      return found
+        .flatMap((row) =>
+          row.source.type === "execution" ? [{ id: row.id, parentId: row.source.executionId }] : []
+        )
+        .sort((left, right) => (left.id < right.id ? -1 : left.id > right.id ? 1 : 0))
+    })
+  }
+}
+
+function isFromSession(
+  row: ExecutionRecord,
+  session: ListSessionExecutionsInput["session"]
+): boolean {
+  const ref = row.authorizationRef
+
+  if (session.type === "user") {
+    return (
+      ref.type === "principal" &&
+      ref.credential?.type === "session" &&
+      ref.credential.id === session.id
+    )
+  }
+
+  return ref.type === "delegated" && ref.delegation.sessionId === session.id
 }
 
 export type InMemoryExecutionStorageSnapshot = Map<string, ExecutionRecord>

package/src/storage/executions/index.ts

@@ -11,6 +11,11 @@ export type {
   CreateExecutionInput,
   DurableExecutionExecutor,
   DurableExecutionSource,
+  ExecutionDescendant,
   ExecutionRecord,
+  ExecutionSessionRef,
   ExecutionStorage,
+  ListExecutionDescendantsInput,
+  ListSessionExecutionsInput,
+  SessionExecutions,
 } from "./types"

package/src/storage/executions/provider.ts

@@ -11,6 +11,18 @@ export {
   validateExecutionRecordReferences,
 } from "./validation"
 
+/** Oldest first, then by id compared byte by byte: the order `listBySession` returns. */
+export function compareExecutionCreation(
+  left: Pick<ExecutionRecord, "createdAt" | "id">,
+  right: Pick<ExecutionRecord, "createdAt" | "id">
+): number {
+  const byTime = left.createdAt.getTime() - right.createdAt.getTime()
+  if (byTime !== 0) {
+    return byTime
+  }
+  return left.id < right.id ? -1 : left.id > right.id ? 1 : 0
+}
+
 /** Provider-neutral flattened representation used by the SQL adapters. */
 export interface ExecutionStorageRow {
   readonly projectId: string

package/src/storage/executions/types.ts

@@ -44,6 +44,45 @@ export type CreateExecutionInput = Omit<ExecutionRecord, "createdAt" | "requeste
   readonly requesterGroupIds?: readonly string[]
 }
 
+/**
+ * The verified session a root execution came through: a signed-in user's `SessionRecord`, held as
+ * its authority credential, or a shared link's session, held by its delegation.
+ */
+export type ExecutionSessionRef =
+  | { readonly type: "user"; readonly id: string }
+  | { readonly type: "share"; readonly id: string }
+
+export interface ListSessionExecutionsInput {
+  readonly projectId: string
+  readonly session: ExecutionSessionRef
+  /** Roots, executions without a parent, created in `[from, to)`. */
+  readonly from: Date
+  readonly to: Date
+  /** Roots and descendants together. */
+  readonly limit: number
+}
+
+export interface SessionExecutions {
+  /** The roots and every descendant, whenever it was created, ordered by `createdAt` then id. */
+  readonly executions: readonly ExecutionRecord[]
+  /**
+   * More than `limit` were found. Roots are kept before descendants, the earliest first; which
+   * descendants are left out is otherwise unspecified.
+   */
+  readonly truncated: boolean
+}
+
+export interface ListExecutionDescendantsInput {
+  readonly projectId: string
+  readonly executionIds: readonly string[]
+}
+
+/** An execution below the ones asked about, and the execution that caused it. */
+export interface ExecutionDescendant {
+  readonly id: string
+  readonly parentId: string
+}
+
 /** Immutable execution ledger. Records can be created and read, never updated or deleted. */
 export interface ExecutionStorage {
   create(input: CreateExecutionInput): Promise<ExecutionRecord>
@@ -51,4 +90,12 @@ export interface ExecutionStorage {
     readonly projectId: string
     readonly id: string
   }): Promise<ExecutionRecord | null>
+  /** What one session started: its roots in a window, and what they caused through `source`. */
+  listBySession(input: ListSessionExecutionsInput): Promise<SessionExecutions>
+  /**
+   * Everything these executions caused through `source`, at any depth, each once and without the
+   * executions asked about, ordered by id. Unbounded, as a sum over the tree needs all of it, so
+   * each is only its id and its parent's.
+   */
+  listDescendants(input: ListExecutionDescendantsInput): Promise<readonly ExecutionDescendant[]>
 }

package/src/storage/in-memory/index.ts

@@ -1,10 +1,12 @@
 import { AsyncLocalStorage } from "node:async_hooks"
 import { InMemoryActionRunStorage } from "../action-runs"
+import { type ActivityStorage, InMemoryActivityStorage } from "../activity"
 import { type AgentStorage, InMemoryAgentStorage } from "../agents"
 import { type AiAccountingAttribution, type AiCostStorage, InMemoryAiCostStorage } from "../ai-cost"
 import { directModelCallAttribution } from "../ai-cost/attribution"
 import { type AiLimitStorage, InMemoryAiLimitStorage } from "../ai-limits"
 import { type AiUsageStorage, InMemoryAiUsageStorage } from "../ai-usage"
+import { type ArtifactStorage, InMemoryArtifactStorage } from "../artifacts"
 import { type AuthStorage, InMemoryAuthStorage } from "../auth"
 import {
   type ConnectorConnectionStorage,
@@ -80,6 +82,7 @@ export class InMemoryStorage implements Storage {
     shareSessions: this.shareSessionStorage,
   })
   private readonly agentStorage = new InMemoryAgentStorage(this.executionStorage)
+  private readonly artifactStorage = new InMemoryArtifactStorage()
   private readonly aiUsageStorage = new InMemoryAiUsageStorage(this.executionStorage)
   private readonly aiCostStorage = new InMemoryAiCostStorage(this.aiUsageStorage, {
     resolve: (input) => this.resolveAiAccountingAttribution(input),
@@ -122,9 +125,11 @@ export class InMemoryStorage implements Storage {
   private readonly fileUploadSessionStorage = new InMemoryFileUploadSessions()
   private readonly fileDownloadGrantStorage = new InMemoryFileDownloadGrantStorage()
   private readonly connectorConnectionStorage: InMemoryConnectorConnectionStorage
+  private readonly activityStorage = new InMemoryActivityStorage()
   readonly auth: AuthStorage
   readonly executions: ExecutionStorage
   readonly agents: AgentStorage
+  readonly artifacts: ArtifactStorage
   readonly aiUsage: AiUsageStorage
   readonly aiCosts: AiCostStorage
   readonly aiLimits: AiLimitStorage
@@ -141,6 +146,7 @@ export class InMemoryStorage implements Storage {
   readonly fileUploadSessions: FileUploadSessionStore
   readonly fileDownloadGrants: FileDownloadGrantStorage
   readonly connectorConnections: ConnectorConnectionStorage
+  readonly activity: ActivityStorage
 
   constructor(options: InMemoryStorageOptions = {}) {
     this.connectorConnectionStorage = new InMemoryConnectorConnectionStorage(
@@ -155,6 +161,7 @@ export class InMemoryStorage implements Storage {
     this.auth = createAuthOperationScope(this.authStorage, scope)
     this.executions = createOperationScopedFacade(this.executionStorage, scope)
     this.agents = createAgentOperationScope(this.agentStorage, scope)
+    this.artifacts = createOperationScopedFacade(this.artifactStorage, scope)
     this.aiUsage = createOperationScopedFacade(this.aiUsageStorage, scope)
     this.aiCosts = createOperationScopedFacade(this.aiCostStorage, scope)
     this.aiLimits = createOperationScopedFacade(this.aiLimitStorage, scope)
@@ -174,6 +181,7 @@ export class InMemoryStorage implements Storage {
     this.fileUploadSessions = createOperationScopedFacade(this.fileUploadSessionStorage, scope)
     this.fileDownloadGrants = createOperationScopedFacade(this.fileDownloadGrantStorage, scope)
     this.connectorConnections = createOperationScopedFacade(this.connectorConnectionStorage, scope)
+    this.activity = createOperationScopedFacade(this.activityStorage, scope)
     this.ontologyStorage = new InMemoryOntologyStorage(this.objectStorage, this.timeseriesStorage, {
       runRootOperation: async (run) => run(),
       getTransactionToken: () => this.getActiveTransactionToken(),
@@ -368,6 +376,7 @@ export class InMemoryStorage implements Storage {
       auth: this.authStorage,
       executions: this.executionStorage,
       agents: this.agentStorage,
+      artifacts: this.artifactStorage,
       aiUsage: this.aiUsageStorage,
       aiCosts: this.aiCostStorage,
       aiLimits: this.aiLimitStorage,
@@ -384,6 +393,7 @@ export class InMemoryStorage implements Storage {
       fileUploadSessions: this.fileUploadSessionStorage,
       fileDownloadGrants: this.fileDownloadGrantStorage,
       connectorConnections: this.connectorConnectionStorage,
+      activity: this.activityStorage,
       ping: async () => undefined,
       transaction: async <T>(): Promise<T> => {
         throwNestedStorageTransaction()
@@ -399,6 +409,7 @@ export class InMemoryStorage implements Storage {
       auth: this.authStorage.snapshot(),
       executions: this.executionStorage.snapshot(),
       agents: this.agentStorage.snapshot(),
+      artifacts: this.artifactStorage.snapshot(),
       aiUsage: this.aiUsageStorage.snapshot(),
       aiCosts: this.aiCostStorage.snapshot(),
       aiLimits: this.aiLimitStorage.snapshot(),
@@ -415,6 +426,7 @@ export class InMemoryStorage implements Storage {
       fileUploadSessions: this.fileUploadSessionStorage.snapshot(),
       fileDownloadGrants: this.fileDownloadGrantStorage.snapshot(),
       connectorConnections: this.connectorConnectionStorage.snapshot(),
+      activity: this.activityStorage.snapshot(),
     }
   }
 
@@ -425,6 +437,7 @@ export class InMemoryStorage implements Storage {
     this.authStorage.restore(snapshot.auth)
     this.executionStorage.restore(snapshot.executions)
     this.agentStorage.restore(snapshot.agents)
+    this.artifactStorage.restore(snapshot.artifacts)
     this.aiUsageStorage.restore(snapshot.aiUsage)
     this.aiCostStorage.restore(snapshot.aiCosts)
     this.aiLimitStorage.restore(snapshot.aiLimits)
@@ -441,6 +454,7 @@ export class InMemoryStorage implements Storage {
     this.fileUploadSessionStorage.restore(snapshot.fileUploadSessions)
     this.fileDownloadGrantStorage.restore(snapshot.fileDownloadGrants)
     this.connectorConnectionStorage.restore(snapshot.connectorConnections)
+    this.activityStorage.restore(snapshot.activity)
   }
 }
 
@@ -451,6 +465,7 @@ export interface InMemoryStorageSnapshot {
   readonly auth: ReturnType<InMemoryAuthStorage["snapshot"]>
   readonly executions: ReturnType<InMemoryExecutionStorage["snapshot"]>
   readonly agents: ReturnType<InMemoryAgentStorage["snapshot"]>
+  readonly artifacts: ReturnType<InMemoryArtifactStorage["snapshot"]>
   readonly aiUsage: ReturnType<InMemoryAiUsageStorage["snapshot"]>
   readonly aiCosts: ReturnType<InMemoryAiCostStorage["snapshot"]>
   readonly aiLimits: ReturnType<InMemoryAiLimitStorage["snapshot"]>
@@ -467,4 +482,5 @@ export interface InMemoryStorageSnapshot {
   readonly fileUploadSessions: ReturnType<InMemoryFileUploadSessions["snapshot"]>
   readonly fileDownloadGrants: ReturnType<InMemoryFileDownloadGrantStorage["snapshot"]>
   readonly connectorConnections: ReturnType<InMemoryConnectorConnectionStorage["snapshot"]>
+  readonly activity: ReturnType<InMemoryActivityStorage["snapshot"]>
 }