@sixb/core 0.1.7 → 0.1.8

package/src/actions/execution.ts

@@ -1,5 +1,10 @@
 import { canViewActionRun, isAllowed } from "../authorization"
 import type { ExecutionContext } from "../execution"
+import { resolveRuntimeAuthorizationForProject } from "../execution/authorization"
+import {
+  assertAuthorizedObjectReaderBinding,
+  getAuthorizedOntologyView,
+} from "../execution/authorized-object-reader"
 import type { ObjectType } from "../ontology"
 import type { SixbRuntimeContext } from "../runtime/types"
 import type {
@@ -7,6 +12,8 @@ import type {
   ListActionRunsInput,
   ListActionRunsResult,
 } from "../storage/action-runs"
+import { assertObjectReadOutputWithinLimit } from "../storage/objects/execution-limits"
+import { type ActionDescriptor, snapshotActionDescriptor } from "./descriptor"
 import {
   type RequestActionAndWaitInput,
   type RequestActionInput,
@@ -14,6 +21,7 @@ import {
   requestAction,
   requestActionAndWait,
 } from "./request"
+import { canDelegationAccessActionRun } from "./run-authorization"
 import type { ActionDefinition } from "./types"
 
 export interface ActionRunsRuntime {
@@ -24,10 +32,10 @@ export interface ActionRunsRuntime {
 }
 
 export interface ActionsRuntime {
-  list(): readonly ActionDefinition[]
-  getById(actionId: string): ActionDefinition | null
-  listGlobal(): readonly ActionDefinition[]
-  listForType(objectType: ObjectType): readonly ActionDefinition[]
+  list(): readonly ActionDescriptor[]
+  getById(actionId: string): ActionDescriptor | null
+  listGlobal(): readonly ActionDescriptor[]
+  listForType(objectType: ObjectType): readonly ActionDescriptor[]
   request(input: RequestActionInput): Promise<RequestActionResult>
   requestAndWait(input: RequestActionAndWaitInput): Promise<ActionRunRecord>
   readonly runs: ActionRunsRuntime
@@ -37,45 +45,112 @@ export function createActionsRuntime(
   runtime: SixbRuntimeContext,
   execution: ExecutionContext
 ): ActionsRuntime {
-  const canList = (action: ActionDefinition) =>
-    isAllowed(runtime.authorization, { kind: "action.apply", actionId: action.id }) &&
-    (action.binding.kind === "global" ||
-      isAllowed(runtime.authorization, {
-        kind: "object.view",
-        objectTypeId: action.binding.objectType.id,
-      }))
+  const projectId = runtime.projectId
+  const runtimeAuthorization = runtime.runtimeAuthorization
+  const objectReader = runtime.objectReader
+  assertAuthorizedObjectReaderBinding({
+    reader: objectReader,
+    scope: { execution, authorization: runtimeAuthorization },
+  })
+  const authorization = resolveRuntimeAuthorizationForProject({
+    projectId,
+    runtimeAuthorization,
+  })
+  const canList = (action: ActionDefinition) => {
+    if (authorization.type === "denied") return false
+    if (authorization.type === "delegated") {
+      const binding = action.binding
+      return (
+        binding.kind === "object" &&
+        authorization.actionApply.some(
+          (target) =>
+            target.actionId === action.id && target.subject.objectTypeId === binding.objectType.id
+        ) &&
+        getAuthorizedOntologyView(objectReader).getObjectTypeById(binding.objectType.id) !== null
+      )
+    }
+    if (authorization.type === "unrestricted") return true
+    return (
+      isAllowed(authorization.context, { kind: "action.apply", actionId: action.id }) &&
+      (action.binding.kind === "global" ||
+        isAllowed(authorization.context, {
+          kind: "object.view",
+          objectTypeId: action.binding.objectType.id,
+        }))
+    )
+  }
+
+  const release = <T>(value: T): T => {
+    if (authorization.type === "delegated") {
+      assertObjectReadOutputWithinLimit(value, authorization.objectRead.limits)
+    }
+    return value
+  }
+  const describeAll = (actions: readonly ActionDefinition[]) =>
+    release(actions.filter(canList).map(snapshotActionDescriptor))
 
   return {
-    list: () => runtime.actionRegistry.list().filter(canList),
+    list: () => describeAll(runtime.actionRegistry.list()),
     getById: (actionId) => {
       const action = runtime.actionRegistry.getById(actionId)
-      return action && canList(action) ? action : null
+      return release(action && canList(action) ? snapshotActionDescriptor(action) : null)
     },
-    listGlobal: () => runtime.actionRegistry.listGlobal().filter(canList),
-    listForType: (objectType) => runtime.actionRegistry.listForType(objectType).filter(canList),
+    listGlobal: () => describeAll(runtime.actionRegistry.listGlobal()),
+    listForType: (objectType) =>
+      describeAll(
+        runtime.actionRegistry
+          .listForType(objectType)
+          .filter(
+            (action) =>
+              authorization.type !== "delegated" ||
+              (action.binding.kind === "object" && action.binding.objectType.id === objectType.id)
+          )
+      ),
     request: (input) => requestAction(runtime, execution, input),
     requestAndWait: (input) => requestActionAndWait(runtime, execution, input),
     runs: {
       getById: async (runId) => {
+        if (
+          authorization.type === "denied" ||
+          (authorization.type === "delegated" &&
+            (!authorization.delegation || authorization.actionApply.length === 0))
+        )
+          return null
         const run =
           (await runtime.storage.actionRuns?.getById({
-            projectId: runtime.projectId,
+            projectId,
             id: runId,
           })) ?? null
-        return run && canViewActionRun(runtime.authorization, run) ? run : null
+        return run &&
+          (authorization.type === "unrestricted" ||
+            (authorization.type === "principal" && canViewActionRun(authorization.context, run)) ||
+            (authorization.type === "delegated" &&
+              (await canDelegationAccessActionRun({
+                storage: runtime.storage,
+                projectId,
+                authority: authorization,
+                run,
+              }))))
+          ? release(run)
+          : null
       },
       list: (input = {}) => {
+        if (authorization.type === "denied" || authorization.type === "delegated") {
+          return Promise.resolve({ runs: [], hasMore: false, total: 0 })
+        }
         const storage = runtime.storage.actionRuns
         if (!storage) return Promise.resolve({ runs: [], hasMore: false, total: 0 })
         return storage.list({
-          projectId: runtime.projectId,
           ...input,
-          actionIds: runtime.authorization
-            ? [...runtime.authorization.grants["apply:action"]]
-            : undefined,
-          objectTypeIds: runtime.authorization
-            ? [...runtime.authorization.grants["view:object"]]
-            : undefined,
+          projectId,
+          actionIds:
+            authorization.type === "principal"
+              ? [...authorization.context.grants["apply:action"]]
+              : undefined,
+          objectTypeIds:
+            authorization.type === "principal"
+              ? [...authorization.context.grants["view:object"]]
+              : undefined,
         })
       },
     },

package/src/actions/request.ts

@@ -1,4 +1,9 @@
-import { assertAuthorized } from "../authorization"
+import { AuthorizationError, assertAuthorized, canViewActionRun } from "../authorization"
+import {
+  getAuthorizationRef,
+  resolveExecutionScopeAuthorization,
+  resolveRuntimeAuthorizationForProject,
+} from "../execution/authorization"
 import {
   createPrimitiveExecutionRecord,
   ensureExecutionRecord,
@@ -15,6 +20,9 @@ import {
   type ActionRunStorage,
   isTerminalActionRun,
 } from "../storage"
+import { assertObjectReadOutputWithinLimit } from "../storage/objects/execution-limits"
+import { admitDelegatedObjectAction, assertDelegatedActionTarget } from "./delegated-admission"
+import { actionRunBelongsToShareGrant, canDelegationAccessActionRun } from "./run-authorization"
 import { dispatchActionRun } from "./run-dispatch"
 import { createActionRunId } from "./run-id"
 import type { ActionDefinition, ActionSubject } from "./types"
@@ -83,16 +91,46 @@ export async function requestAction(
   execution: ExecutionContext,
   input: RequestActionInput
 ): Promise<RequestActionResult> {
-  requireActionRunStorage(runtime)
-  const action = getActionDefinition(runtime, input.actionId)
+  // Capture the three process-local capabilities before caller-owned request getters can run.
+  const projectId = runtime.projectId
+  const runtimeAuthorization = runtime.runtimeAuthorization
+  const objectReader = runtime.objectReader
+  const request = snapshotActionRequest(input)
+  const authorization = resolveExecutionScopeAuthorization(projectId, {
+    execution,
+    authorization: runtimeAuthorization,
+  })
+  const subject = request.subject
+  const delegatedSubject =
+    authorization.type === "delegated"
+      ? assertDelegatedActionTarget({
+          authorization,
+          actionId: request.actionId,
+          subject,
+        })
+      : undefined
+  const action = getActionDefinition(runtime, request.actionId)
   const actionId = action.id
-  const rawParams: Record<string, unknown> = input.params ?? {}
-  const subject: ActionSubject = input.subject ?? { kind: "none" }
-
-  assertAuthorized(runtime, { kind: "action.apply", actionId })
-  if (action.binding.kind === "object") {
+  const rawParams = request.params
+
+  if (authorization.type === "delegated") {
+    await admitDelegatedObjectAction({
+      objectReader,
+      runtimeAuthorization,
+      execution,
+      authorization,
+      action,
+      subject: delegatedSubject!,
+    })
+  } else {
+    assertAuthorized({ projectId, runtimeAuthorization }, { kind: "action.apply", actionId })
+  }
+  if (authorization.type !== "delegated" && action.binding.kind === "object") {
     // Object actions also require visibility of the subject's object type.
-    assertAuthorized(runtime, { kind: "object.view", objectTypeId: action.binding.objectType.id })
+    assertAuthorized(
+      { projectId, runtimeAuthorization },
+      { kind: "object.view", objectTypeId: action.binding.objectType.id }
+    )
   }
 
   validateActionSubject(action, subject)
@@ -107,22 +145,49 @@ export async function requestAction(
 
   const actionParams = normalizeActionParams(runtime, action.params, rawParams, pathPrefix)
 
+  // `dispatchActionRun` checks an existing run id before creating its durable execution. Keep
+  // process-local delegation outside that oracle unless it carries durable grant provenance.
+  void getAuthorizationRef(runtimeAuthorization)
+
   return dispatchActionRun({
     errorReporterHost: runtime,
-    projectId: runtime.projectId,
+    projectId,
     storage: runtime.storage,
     queue: runtime.queues.actions,
     events: runtime.events,
     actionId,
     subject,
     params: actionParams,
-    runId: input.runId,
+    runId: request.runId,
+    ...(authorization.type === "delegated"
+      ? {
+          assertCanReuseExisting: async (
+            storage: SixbRuntimeContext["storage"],
+            existing: ActionRunRecord
+          ) => {
+            if (
+              !authorization.delegation ||
+              !(await actionRunBelongsToShareGrant({
+                storage,
+                projectId,
+                run: existing,
+                grantId: authorization.delegation.grantId,
+              }))
+            ) {
+              throw new AuthorizationError(
+                `apply:action:${actionId}`,
+                "[Sixb] Delegated authority cannot reuse this Action run."
+              )
+            }
+          },
+        }
+      : {}),
     createExecution: async (executionId, runId) => {
       const caller = await ensureExecutionRecord(
         runtime.storage.executions,
         executionRecordInputFromRuntime({
           execution,
-          runtimeAuthorization: runtime.runtimeAuthorization,
+          runtimeAuthorization,
         })
       )
       return createPrimitiveExecutionRecord({
@@ -134,6 +199,24 @@ export async function requestAction(
   })
 }
 
+function snapshotActionRequest(input: RequestActionInput): {
+  readonly actionId: string
+  readonly subject: ActionSubject
+  readonly params: Record<string, unknown>
+  readonly runId?: string
+} {
+  const actionId = input.actionId
+  const subject = input.subject
+  const params = input.params
+  const runId = input.runId
+  return structuredClone({
+    actionId,
+    subject: subject ?? { kind: "none" },
+    params: params ?? {},
+    ...(runId === undefined ? {} : { runId }),
+  })
+}
+
 export async function requestActionAndWait(
   runtime: SixbRuntimeContext,
   execution: ExecutionContext,
@@ -158,9 +241,28 @@ export async function waitForActionRun(
   runtime: SixbRuntimeContext,
   input: WaitForActionRunInput
 ): Promise<ActionRunRecord> {
+  const projectId = runtime.projectId
+  const runtimeAuthorization = runtime.runtimeAuthorization
+  const request = {
+    runId: input.runId,
+    timeoutMs: input.timeoutMs,
+    signal: input.signal,
+  }
+  const authorization = resolveRuntimeAuthorizationForProject({
+    projectId,
+    runtimeAuthorization,
+  })
+  if (authorization.type === "denied") {
+    throw new AuthorizationError(
+      "runtime:unbound",
+      "[Sixb] Protected operations require registered runtime authorization for this project."
+    )
+  }
+  // Process-local delegation cannot poll durable runs without originating grant provenance.
+  if (authorization.type === "delegated") void getAuthorizationRef(runtimeAuthorization)
   const actionRuns = requireActionRunStorage(runtime)
-  const timeoutMs = input.timeoutMs ?? DEFAULT_ACTION_WAIT_TIMEOUT_MS
-  const signal = input.signal
+  const timeoutMs = request.timeoutMs ?? DEFAULT_ACTION_WAIT_TIMEOUT_MS
+  const signal = request.signal
   const startedAt = Date.now()
 
   if (signal?.aborted) {
@@ -213,10 +315,25 @@ export async function waitForActionRun(
       checking = true
       try {
         const record = await actionRuns.getById({
-          projectId: runtime.projectId,
-          id: input.runId,
+          projectId,
+          id: request.runId,
         })
-        if (record && isTerminalActionRun(record)) {
+        const visible =
+          record &&
+          (authorization.type === "unrestricted" ||
+            (authorization.type === "principal" &&
+              canViewActionRun(authorization.context, record)) ||
+            (authorization.type === "delegated" &&
+              (await canDelegationAccessActionRun({
+                storage: runtime.storage,
+                projectId,
+                authority: authorization,
+                run: record,
+              }))))
+        if (visible && isTerminalActionRun(record)) {
+          if (authorization.type === "delegated") {
+            assertObjectReadOutputWithinLimit(record, authorization.objectRead.limits)
+          }
           cleanup()
           resolve(record)
           return
@@ -235,7 +352,7 @@ export async function waitForActionRun(
 
     timer = setTimeout(
       () => {
-        rejectWith(new ActionRunTimeoutError({ runId: input.runId, timeoutMs }))
+        rejectWith(new ActionRunTimeoutError({ runId: request.runId, timeoutMs }))
       },
       Math.max(0, timeoutMs - (Date.now() - startedAt))
     )
@@ -250,7 +367,7 @@ export async function waitForActionRun(
           events.some(
             (event) =>
               (event.type === "action.completed" || event.type === "action.failed") &&
-              event.payload.runId === input.runId
+              event.payload.runId === request.runId
           )
         ) {
           void check()

package/src/actions/run-authorization.ts

@@ -0,0 +1,53 @@
+import type { ResolvedRuntimeAuthorization } from "../execution/authorization"
+import type { Storage } from "../storage"
+import type { ActionRunRecord } from "../storage/action-runs"
+import { findPrimitiveParentRequestExecution } from "../storage/executions/run-link"
+
+/** Check both current grant scope and immutable request provenance for a delegated Action run. */
+export async function canDelegationAccessActionRun(input: {
+  readonly storage: Storage
+  readonly projectId: string
+  readonly authority: Extract<ResolvedRuntimeAuthorization, { readonly type: "delegated" }>
+  readonly run: ActionRunRecord
+}): Promise<boolean> {
+  const subject = input.run.subject
+  if (
+    !input.authority.delegation ||
+    subject.kind !== "object" ||
+    !input.authority.actionApply.some(
+      (target) =>
+        target.actionId === input.run.actionId &&
+        target.subject.objectTypeId === subject.objectTypeId &&
+        target.subject.primaryId === subject.primaryId
+    )
+  ) {
+    return false
+  }
+  return actionRunBelongsToShareGrant({
+    storage: input.storage,
+    projectId: input.projectId,
+    run: input.run,
+    grantId: input.authority.delegation.grantId,
+  })
+}
+
+/** Session ids remain audit provenance; the issued grant is the durable capability identity. */
+export async function actionRunBelongsToShareGrant(input: {
+  readonly storage: Storage
+  readonly projectId: string
+  readonly run: ActionRunRecord
+  readonly grantId: string
+}): Promise<boolean> {
+  const parent = await findPrimitiveParentRequestExecution({
+    executions: input.storage.executions,
+    projectId: input.projectId,
+    executionId: input.run.executionId,
+    primitive: { kind: "action", id: input.run.actionId, runId: input.run.id },
+  })
+  const authorization = parent?.authorizationRef
+  return (
+    authorization?.type === "delegated" &&
+    authorization.delegation.kind === "share" &&
+    authorization.delegation.grantId === input.grantId
+  )
+}

package/src/actions/run-dispatch.ts

@@ -32,6 +32,8 @@ interface DispatchActionRunInput {
   readonly params: ActionRunParams
   readonly runId?: string
   readonly createExecution: (executionId: string, runId: string) => Promise<CreateExecutionInput>
+  /** Runs before payload comparison or retry so an existing run cannot cross authority owners. */
+  readonly assertCanReuseExisting?: (storage: Storage, run: ActionRunRecord) => void | Promise<void>
 }
 
 interface PreparedActionRun {
@@ -73,7 +75,10 @@ async function persistActionRun(
 ): Promise<PersistedActionRun> {
   const actionRuns = requireActionRunStorage(input.storage)
   const existing = await actionRuns.getById({ projectId: input.projectId, id: request.runId })
-  if (existing) return reuseActionRun(input, existing)
+  if (existing) {
+    await input.assertCanReuseExisting?.(input.storage, existing)
+    return reuseActionRun(input, existing)
+  }
 
   const execution = await input.createExecution(`exec_${randomUUID()}`, request.runId)
   const queuedAt = new Date()
@@ -86,6 +91,7 @@ async function persistActionRun(
           id: request.runId,
         })
         if (raced) {
+          await input.assertCanReuseExisting?.(tx, raced)
           assertExistingRunMatchesRequest(raced, input)
           return { publish: false, run: raced }
         }
@@ -109,6 +115,7 @@ async function persistActionRun(
     if (!(error instanceof ActionRunError)) throw error
     const raced = await actionRuns.getById({ projectId: input.projectId, id: request.runId })
     if (!raced) throw error
+    await input.assertCanReuseExisting?.(input.storage, raced)
     assertExistingRunMatchesRequest(raced, input)
     return { publish: false, run: raced }
   }