@sixb/core 0.1.6 → 0.1.8

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 }
   }