@sixb/core 0.1.19 → 0.1.21

package/src/execution/object-reader-clearance.ts

@@ -0,0 +1,91 @@
+import { type PropertyClearance, resolvePropertyClearance } from "../objects/property-clearance"
+import type { OntologyRegistry } from "../ontology"
+import type { AppliedMarkings } from "../security/applied-markings"
+import type { EventOriginRef } from "../security/applied-markings-contribution"
+import type { AppliedMarkingsSnapshot } from "../security/applied-markings-snapshot"
+
+/** What one read may not return; `undefined` when it reads everything. */
+export type Clearance = PropertyClearance | undefined
+
+/**
+ * What one authority cannot read: the markings the code declares, and those the dataset versions
+ * projections applied add, for an authority they can affect.
+ *
+ * A reader they cannot affect, trusted code included, gets the code's clearance as a plain value:
+ * awaiting it costs one microtask, not a refresh. Otherwise the clearance is resolved for each
+ * snapshot, which rarely changes, so the last one is kept.
+ */
+export class ObjectReaderClearance {
+  readonly #ontology: OntologyRegistry
+  /** What the authority cannot read under the code's markings; absent when it reads everything. */
+  readonly #static: Clearance
+  /** The authority's clearances; absent when it is unrestricted. */
+  readonly #clearances?: ReadonlySet<string>
+  /** Present only when applied dataset versions can deny this authority more than the code. */
+  readonly #applied?: AppliedMarkings
+  #lastSnapshot?: AppliedMarkingsSnapshot
+  #lastClearance: Clearance
+
+  constructor(input: {
+    readonly ontology: OntologyRegistry
+    readonly clearances: ReadonlySet<string> | undefined
+    readonly appliedMarkings?: AppliedMarkings
+  }) {
+    this.#ontology = input.ontology
+    this.#clearances = input.clearances
+    this.#static = input.clearances && resolvePropertyClearance(input.ontology, input.clearances)
+
+    if (input.clearances && input.appliedMarkings?.affects(input.clearances)) {
+      this.#applied = input.appliedMarkings
+    }
+
+    Object.freeze(this)
+  }
+
+  /** What the authority cannot read now. */
+  current(): Clearance | Promise<Clearance> {
+    const applied = this.#applied
+    const clearances = this.#clearances
+    if (!applied || !clearances) return this.#static
+
+    return applied.current().then((snapshot) => {
+      if (snapshot !== this.#lastSnapshot) {
+        this.#lastClearance = resolvePropertyClearance(this.#ontology, clearances, snapshot)
+        this.#lastSnapshot = snapshot
+      }
+      return this.#lastClearance
+    })
+  }
+
+  /**
+   * What the authority cannot read in an object event. Reads the event's origin version only for
+   * an authority its markings affect.
+   */
+  forEvent(sources: EventSources): Clearance | Promise<Clearance> {
+    const applied = this.#applied
+    const clearances = this.#clearances
+    if (!applied || !clearances) return this.#static
+
+    return applied
+      .current()
+      .then((snapshot) =>
+        sources.origin ? applied.forEventOrigin(snapshot, sources.origin) : snapshot
+      )
+      .then((snapshot) =>
+        sources.earlier ? applied.forEarlierValues(snapshot, sources.objectTypeId) : snapshot
+      )
+      .then((snapshot) => resolvePropertyClearance(this.#ontology, clearances, snapshot))
+  }
+}
+
+/** Where the values of an object event came from. */
+export interface EventSources {
+  readonly objectTypeId: string
+  /** The projection that emitted the event, and the version it applied. */
+  readonly origin?: EventOriginRef
+  /**
+   * Whether the event holds values from before it, which came from versions applied earlier: an
+   * update or a deletion, or a record an action or a direct write took of projected values.
+   */
+  readonly earlier: boolean
+}

package/src/execution/object-reader-ontology.ts

@@ -0,0 +1,63 @@
+import { isAllowed } from "../authorization"
+import {
+  type AuthorizedOntologySelection,
+  type AuthorizedOntologyView,
+  createAuthorizedOntologyView,
+} from "../objects/authorized-ontology-view"
+import type { OntologyRegistry } from "../ontology"
+import { assertObjectReadOutputWithinLimit } from "../storage"
+import type { ResolvedExecutionAuthority } from "./object-reader-security"
+
+/** The ontology a reader resolves against, and the part of it its authority may describe. */
+export class ObjectReaderOntology {
+  readonly registry: OntologyRegistry
+  readonly #authority: ResolvedExecutionAuthority
+  #view?: AuthorizedOntologyView
+
+  constructor(registry: OntologyRegistry, authority: ResolvedExecutionAuthority) {
+    this.registry = registry
+    this.#authority = authority
+    Object.freeze(this)
+  }
+
+  /** Inert metadata for the types the authority may view, built on first use. */
+  view(): AuthorizedOntologyView {
+    const authority = this.#authority
+    this.#view ??= createAuthorizedOntologyView({
+      ontology: this.registry,
+      selection: selectionForAuthority(authority, this.registry),
+      ...(authority.type === "delegated"
+        ? {
+            assertOutputWithinLimit: (value: unknown) =>
+              assertObjectReadOutputWithinLimit(value, authority.objectRead.limits),
+          }
+        : {}),
+    })
+    return this.#view
+  }
+}
+
+function selectionForAuthority(
+  authority: ResolvedExecutionAuthority,
+  ontology: OntologyRegistry
+): AuthorizedOntologySelection {
+  switch (authority.type) {
+    case "unrestricted":
+      return { kind: "all" }
+    case "principal":
+      return {
+        kind: "types",
+        objectTypeIds: ontology
+          .listObjectTypes()
+          .filter((objectType) =>
+            isAllowed(authority.context, {
+              kind: "object.view",
+              objectTypeId: objectType.id,
+            })
+          )
+          .map((objectType) => objectType.id),
+      }
+    case "delegated":
+      return { kind: "selected", scope: authority.objectRead.scope }
+  }
+}

package/src/execution/object-reader-security.ts

@@ -0,0 +1,146 @@
+import { assertAuthorized, isAllowed } from "../authorization"
+import { AuthorizationError } from "../authorization/errors"
+import type { AuthorizationContext } from "../authorization/types"
+import { unreadableError } from "../objects/property-clearance"
+import {
+  createSelectedObjectQueryAdmission,
+  type SelectedObjectQueryAdmission,
+} from "../objects/query/selected-read-admission"
+import type { OntologyRegistry } from "../ontology"
+import type { AppliedMarkings } from "../security/applied-markings"
+import type { CompiledObjectReadStep, ObjectLinkRow } from "../storage"
+import type { resolveExecutionScopeAuthorization } from "./authorization"
+import { type Clearance, ObjectReaderClearance } from "./object-reader-clearance"
+import type { RuntimeAuthorization } from "./types"
+
+export type ResolvedExecutionAuthority = ReturnType<typeof resolveExecutionScopeAuthorization>
+
+export type RuntimeReadAuthorization = {
+  readonly projectId: string
+  readonly runtimeAuthorization: RuntimeAuthorization
+  readonly authorization?: AuthorizationContext
+}
+
+/** What a delegated authority selected: the object types, links, and queries it may read. */
+export interface ObjectReaderDelegation {
+  readonly objectTypeIds: ReadonlySet<string>
+  readonly linkDefinitions: ReadonlySet<string>
+  readonly queryAdmission: SelectedObjectQueryAdmission
+}
+
+/**
+ * Who reads, and what it may read: the exact execution authority, the selection a delegated one
+ * carries, and its clearance. It decides whether an object type or a link is viewable.
+ */
+export class ObjectReaderSecurity {
+  /** The registered authority the reader is bound to. */
+  readonly authorization: RuntimeAuthorization
+  readonly authority: ResolvedExecutionAuthority
+  /** The authority as generic authorization checks take it. */
+  readonly runtime: RuntimeReadAuthorization
+  /** Present for delegated authority only. */
+  readonly delegation?: ObjectReaderDelegation
+  readonly clearance: ObjectReaderClearance
+
+  constructor(input: {
+    readonly authorization: RuntimeAuthorization
+    readonly authority: ResolvedExecutionAuthority
+    readonly projectId: string
+    readonly ontology: OntologyRegistry
+    readonly appliedMarkings?: AppliedMarkings
+  }) {
+    const authority = input.authority
+    this.authorization = input.authorization
+    this.authority = authority
+    this.runtime = Object.freeze({
+      projectId: input.projectId,
+      runtimeAuthorization: input.authorization,
+      ...(authority.type === "principal" ? { authorization: authority.context } : {}),
+    })
+
+    if (authority.type === "delegated") {
+      const scope = authority.objectRead.scope
+      this.delegation = Object.freeze({
+        objectTypeIds: new Set(scope.objects.map((object) => object.objectTypeId)),
+        linkDefinitions: new Set(scope.steps.map(delegatedLinkDefinitionKey)),
+        queryAdmission: createSelectedObjectQueryAdmission(scope),
+      })
+    }
+
+    this.clearance = new ObjectReaderClearance({
+      ontology: input.ontology,
+      clearances: clearancesForAuthority(authority),
+      ...(input.appliedMarkings === undefined ? {} : { appliedMarkings: input.appliedMarkings }),
+    })
+
+    Object.freeze(this)
+  }
+
+  assertObjectTypesViewable(objectTypeIds: readonly string[], clearance: Clearance): void {
+    if (this.delegation) {
+      for (const objectTypeId of new Set(objectTypeIds)) {
+        if (this.delegation.objectTypeIds.has(objectTypeId)) continue
+        throw new AuthorizationError(
+          `delegated:object.view:${objectTypeId}`,
+          `[Sixb] Delegated authorization does not select object type '${objectTypeId}'.`
+        )
+      }
+    } else {
+      for (const objectTypeId of new Set(objectTypeIds)) {
+        assertAuthorized(this.runtime, { kind: "object.view", objectTypeId })
+      }
+    }
+
+    if (!clearance) return
+
+    for (const objectTypeId of new Set(objectTypeIds)) {
+      const unreadable = clearance.unreadableType(objectTypeId)
+      if (unreadable) throw unreadableError(unreadable)
+    }
+  }
+
+  isObjectTypeViewable(objectTypeId: string, clearance: Clearance): boolean {
+    if (clearance?.unreadableType(objectTypeId)) return false
+    if (this.delegation) return this.delegation.objectTypeIds.has(objectTypeId)
+    return isAllowed(this.runtime.authorization, { kind: "object.view", objectTypeId })
+  }
+
+  isLinkViewable(link: ObjectLinkRow, clearance: Clearance): boolean {
+    if (
+      !this.isObjectTypeViewable(link.sourceTypeId, clearance) ||
+      !this.isObjectTypeViewable(link.targetTypeId, clearance) ||
+      clearance?.unreadableLink(link.sourceTypeId, link.linkId)
+    ) {
+      return false
+    }
+
+    return this.delegation?.linkDefinitions.has(delegatedLinkDefinitionKey(link)) ?? true
+  }
+}
+
+/**
+ * Unrestricted authority reads every property. A principal reads what its roles clear; delegated
+ * shared access carries no clearance, so no share can expose a marked property.
+ */
+function clearancesForAuthority(
+  authority: ResolvedExecutionAuthority
+): ReadonlySet<string> | undefined {
+  switch (authority.type) {
+    case "unrestricted":
+      return undefined
+    case "principal":
+      return authority.context.clearances ?? new Set()
+    case "delegated":
+      return new Set()
+  }
+}
+
+function delegatedLinkDefinitionKey(
+  input:
+    | Pick<CompiledObjectReadStep, "sourceObjectTypeId" | "linkId" | "targetObjectTypeId">
+    | Pick<ObjectLinkRow, "sourceTypeId" | "linkId" | "targetTypeId">
+): string {
+  return "sourceObjectTypeId" in input
+    ? JSON.stringify([input.sourceObjectTypeId, input.linkId, input.targetObjectTypeId])
+    : JSON.stringify([input.sourceTypeId, input.linkId, input.targetTypeId])
+}

package/src/http/api-routes.ts

@@ -430,6 +430,71 @@ export const SIXB_API_ROUTES: readonly SixbApiRoute[] = [
     accessToken: true,
     agentApi: false,
   },
+  // Artifacts are reachable with an access token, so the CLI and integrations can publish them. The
+  // Agent publishes through its own tool, not the gateway.
+  {
+    operationId: "listArtifacts",
+    method: "GET",
+    path: "/api/artifacts",
+    accessToken: true,
+    agentApi: false,
+  },
+  {
+    operationId: "createArtifact",
+    method: "POST",
+    path: "/api/artifacts",
+    accessToken: true,
+    agentApi: false,
+  },
+  {
+    operationId: "getArtifact",
+    method: "GET",
+    path: "/api/artifacts/:artifactId",
+    accessToken: true,
+    agentApi: false,
+  },
+  {
+    operationId: "deleteArtifact",
+    method: "DELETE",
+    path: "/api/artifacts/:artifactId",
+    accessToken: true,
+    agentApi: false,
+  },
+  {
+    operationId: "publishArtifactVersion",
+    method: "POST",
+    path: "/api/artifacts/:artifactId/versions",
+    accessToken: true,
+    agentApi: false,
+  },
+  {
+    operationId: "getArtifactVersion",
+    method: "GET",
+    path: "/api/artifacts/:artifactId/versions/:version",
+    accessToken: true,
+    agentApi: false,
+  },
+  {
+    operationId: "createArtifactFrame",
+    method: "POST",
+    path: "/api/artifacts/:artifactId/versions/:version/frame",
+    accessToken: true,
+    agentApi: false,
+  },
+  {
+    operationId: "getArtifactFileContent",
+    method: "GET",
+    path: "/api/artifacts/:artifactId/versions/:version/content",
+    accessToken: true,
+    agentApi: false,
+  },
+  {
+    operationId: "headArtifactFileContent",
+    method: "HEAD",
+    path: "/api/artifacts/:artifactId/versions/:version/content",
+    accessToken: true,
+    agentApi: false,
+  },
   {
     operationId: "searchObjects",
     method: "GET",
@@ -452,6 +517,66 @@ export const SIXB_API_ROUTES: readonly SixbApiRoute[] = [
     accessToken: true,
     agentApi: false,
   },
+  // A browser records its own activity, signed in or through a shared link. Access tokens never
+  // do: a script is not a visit.
+  {
+    operationId: "getActivityCaptureConfig",
+    method: "GET",
+    path: "/api/activity/capture-config",
+    accessToken: false,
+    agentApi: false,
+    sharedSession: true,
+  },
+  {
+    operationId: "captureActivity",
+    method: "POST",
+    path: "/api/activity/events",
+    accessToken: false,
+    agentApi: false,
+    sharedSession: true,
+  },
+  {
+    operationId: "listActivityVisits",
+    method: "GET",
+    path: "/api/activity/visits",
+    accessToken: true,
+    agentApi: false,
+  },
+  {
+    operationId: "listActivityUsers",
+    method: "GET",
+    path: "/api/activity/users",
+    accessToken: true,
+    agentApi: false,
+  },
+  {
+    operationId: "getActivitySummary",
+    method: "GET",
+    path: "/api/activity/summary",
+    accessToken: true,
+    agentApi: false,
+  },
+  {
+    operationId: "getActivityCalendar",
+    method: "GET",
+    path: "/api/activity/calendar",
+    accessToken: true,
+    agentApi: false,
+  },
+  {
+    operationId: "getActivityVisitTimeline",
+    method: "GET",
+    path: "/api/activity/visits/:visitId/timeline",
+    accessToken: true,
+    agentApi: false,
+  },
+  {
+    operationId: "listActivityConnections",
+    method: "GET",
+    path: "/api/activity/connections",
+    accessToken: true,
+    agentApi: false,
+  },
   {
     operationId: "getAiAccountingOverview",
     method: "GET",

package/src/index.ts

@@ -391,8 +391,6 @@ export {
 
 export type {
   AuthCookieOptions,
-  AuthSessionAudience,
-  AuthSessionAudienceOptions,
   AuthSessionOptions,
   AuthStrategy,
   AuthStrategyKind,
@@ -401,22 +399,14 @@ export type {
   Principal,
   SixbAuthConfig,
 } from "./auth"
-export {
-  DEFAULT_AUTH_SESSION_AUDIENCE,
-  isValidAuthSessionAudience,
-  principalsEqual,
-  resolveAuthSessionAudience,
-  SYSTEM_PRINCIPAL,
-} from "./auth"
+export { principalsEqual, SYSTEM_PRINCIPAL } from "./auth"
 
 // ── Authorization ──────────────────────────────────────────
 
 export type { AuthorizationContext, GrantIndex, GrantKind } from "./authorization"
 export {
   AuthorizationError,
-  canAccessApplication,
   isAllowed,
-  isApplicationAccessControlled,
   resolveAuthorizationContext,
 } from "./authorization"
 
@@ -440,10 +430,8 @@ export type {
 // ── Security Definitions ───────────────────────────────────
 
 export type {
-  AccessGrant,
   AgentRunGrant,
   AppendGrant,
-  ApplicationDefinition,
   ApplyGrant,
   BreadthSelector,
   BreadthTarget,
@@ -463,6 +451,8 @@ export type {
   MembershipPolicyDefinition,
   ObserveGrant,
   ObserveGrantTarget,
+  ProjectReference,
+  ProjectSurfaceReference,
   RedactionReason,
   Redactions,
   RegisteredSecurityDefinitions,
@@ -476,13 +466,13 @@ export type {
   ViewGrantTarget,
 } from "./security"
 export {
-  applications,
   can,
   defineGroup,
   defineMarking,
   defineMembershipPolicy,
   defineRole,
   every,
+  project,
   SecurityValidationError,
 } from "./security"
 
@@ -596,6 +586,7 @@ export type {
   SandboxNetworkPolicy,
   SandboxNetworkTarget,
   SandboxRequestCredential,
+  SandboxRequestMethod,
   SandboxSessionOptions,
   SandboxStatus,
 } from "./sandboxes"
@@ -872,6 +863,38 @@ export type {
 // ── Runtime ─────────────────────────────────────────────────
 
 export type { ActionRunsRuntime, ActionsRuntime } from "./actions/execution"
+export type {
+  ActivityConnection,
+  ActivityConnectionStatus,
+  ActivityConnectionsPage,
+  ActivityConnectionsQuery,
+  ActivitySessionConnection,
+  ActivityShareConnection,
+  ActivityUserConnection,
+} from "./activity/connection"
+export type { ActivityDevice } from "./activity/device"
+export type {
+  ActivityRuntime,
+  ActivityUsersResult,
+  ActivityVisitList,
+} from "./activity/execution"
+export type {
+  ActivityCalendar,
+  ActivityCalendarQuery,
+  ActivityOptions,
+  ActivityPageQuery,
+  ActivityPeriodQuery,
+} from "./activity/service"
+export type { ActivityVisitActor, ActivityVisitView } from "./activity/shares"
+export type {
+  ActivityActionEntry,
+  ActivityAgentEntry,
+  ActivityInteractionEntry,
+  ActivityPageEntry,
+  ActivityTimelineEntry,
+  ActivityVisitTimeline,
+  ActivityWorkflowEntry,
+} from "./activity/timeline"
 export type {
   AgentRunListResult,
   AgentRunsRuntime,
@@ -880,6 +903,18 @@ export type {
   AgentThreadsRuntime,
   ExecutionAgentRunResult,
 } from "./agents/execution"
+export type { ArtifactRequestErrorCode } from "./artifacts/errors"
+export { ArtifactRequestError } from "./artifacts/errors"
+export type {
+  ArtifactContentInput,
+  ArtifactsRuntime,
+  ListArtifactsRuntimeInput,
+} from "./artifacts/execution"
+export type { ArtifactKind } from "./artifacts/kinds"
+export type { ArtifactOutline } from "./artifacts/outline"
+export type { PublishedArtifact } from "./artifacts/publish/publish"
+export type { ArtifactReference } from "./artifacts/references"
+export type { ArtifactWarning } from "./artifacts/warnings"
 export type { CreateFileDownloadUrlOptions, FileDownloadUrl } from "./blob-storage/download-urls"
 export type { BlobsRuntime } from "./blob-storage/execution"
 export type { ConnectorRuntime } from "./connectors/execution"
@@ -1003,6 +1038,18 @@ export type {
   WebhookRunFailureCode,
   WorkflowRunFailureCode,
 } from "./storage"
+export type {
+  ActivityActor,
+  ActivityAttribution,
+  ActivityCursor,
+  ActivityDay,
+  ActivityInteraction,
+  ActivityPageView,
+  ActivitySummary,
+  ActivityUser,
+  ActivityVisit,
+  ActivityVisitsPage,
+} from "./storage/activity/types"
 export type { VectorIndexingFailureCode } from "./storage/ontology/vector-indexing"
 export type { SyncRunsRuntime, SyncsRuntime } from "./syncs/execution"
 export type {
@@ -1046,9 +1093,6 @@ export type {
   AgentSkillDefinition,
   AgentStepStartPart,
   AgentTextPart,
-  AgentToolArtifact,
-  AgentToolArtifactPutInput,
-  AgentToolArtifacts,
   AgentToolAttachments,
   AgentToolCallPart,
   AgentToolCallState,
@@ -1056,7 +1100,10 @@ export type {
   AgentToolContent,
   AgentToolDefinition,
   AgentToolDescriptionBuilder,
+  AgentToolFile,
   AgentToolFileContent,
+  AgentToolFilePutInput,
+  AgentToolFiles,
   AgentToolHandler,
   AgentToolHandlerResult,
   AgentToolInputBuilder,
@@ -1103,6 +1150,14 @@ export type {
   AgentThreadSandboxState,
   ListAgentThreadsResult,
 } from "./storage/agents"
+export type {
+  ArtifactFile,
+  ArtifactOrigin,
+  ArtifactRecord,
+  ArtifactVersionRecord,
+  ListArtifactsResult,
+  ListArtifactVersionsResult,
+} from "./storage/artifacts"
 
 // ── Models ──────────────────────────────────────────────────