@predicatesystems/temporal 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Predicate Systems
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,214 @@
+# @predicatesystems/temporal
+
+Temporal.io Worker Interceptor for Predicate Authority Zero-Trust authorization.
+
+This package provides a pre-execution security gate for all Temporal Activities, enforcing cryptographic authorization mandates before any activity code runs.
+
+## Prerequisites
+
+This package requires the **Predicate Authority Sidecar** daemon to be running. The sidecar is a lightweight Rust binary that handles policy evaluation and mandate signing.
+
+| Resource | Link |
+|----------|------|
+| Sidecar Repository | [github.com/PredicateSystems/predicate-authority-sidecar](https://github.com/PredicateSystems/predicate-authority-sidecar) |
+| Download Binaries | [Latest Releases](https://github.com/PredicateSystems/predicate-authority-sidecar/releases) |
+| License | MIT / Apache 2.0 |
+
+### Quick Sidecar Setup
+
+```bash
+# Download the latest release for your platform
+# Linux x64, macOS x64/ARM64, Windows x64 available
+
+# Extract and run
+tar -xzf predicate-authorityd-*.tar.gz
+chmod +x predicate-authorityd
+
+# Start with a policy file
+./predicate-authorityd --port 8787 --policy-file policy.json
+```
+
+## Installation
+
+```bash
+npm install @predicatesystems/temporal
+# or
+yarn add @predicatesystems/temporal
+# or
+pnpm add @predicatesystems/temporal
+```
+
+## Quick Start
+
+```typescript
+import { Worker } from "@temporalio/worker";
+import { AuthorityClient } from "@predicatesystems/authority";
+import { createPredicateInterceptors } from "@predicatesystems/temporal";
+
+// Initialize the Predicate Authority client
+const authorityClient = new AuthorityClient({
+  baseUrl: "http://127.0.0.1:8787",
+});
+
+// Create interceptors
+const interceptors = createPredicateInterceptors({
+  authorityClient,
+  principal: "temporal-worker",
+});
+
+// Create worker with the interceptors
+const worker = await Worker.create({
+  connection,
+  namespace: "default",
+  taskQueue: "my-task-queue",
+  workflowsPath: require.resolve("./workflows"),
+  activities,
+  interceptors,
+});
+```
+
+## How It Works
+
+The interceptor sits in the Temporal activity execution pipeline:
+
+1. Temporal dispatches an activity to your worker
+2. **Before** the activity code runs, the interceptor extracts:
+   - Activity type (action)
+   - Activity arguments (context)
+3. The interceptor calls `AuthorityClient.authorize()` to request a mandate
+4. If **denied**: throws `PredicateAuthorizationError` - activity never executes
+5. If **approved**: activity proceeds normally
+
+This ensures that no untrusted code or payload reaches your OS until it has been cryptographically authorized.
+
+## Configuration
+
+### Interceptor Options
+
+```typescript
+import { createPredicateInterceptors } from "@predicatesystems/temporal";
+
+const interceptors = createPredicateInterceptors({
+  // Required: The Predicate Authority client
+  authorityClient: new AuthorityClient({ baseUrl: "http://127.0.0.1:8787" }),
+
+  // Optional: Principal ID (default: "temporal-worker")
+  principal: "my-worker",
+
+  // Optional: Tenant ID for multi-tenant setups
+  tenantId: "tenant-123",
+
+  // Optional: Session ID for request correlation
+  sessionId: "session-456",
+
+  // Optional: Custom resource identifier (default: "temporal:activity")
+  resource: "temporal:my-queue",
+});
+```
+
+### Policy File
+
+Create a policy file for the Predicate Authority daemon:
+
+```json
+{
+  "rules": [
+    {
+      "name": "allow-safe-activities",
+      "effect": "allow",
+      "principals": ["temporal-worker"],
+      "actions": ["processOrder", "sendNotification"],
+      "resources": ["*"]
+    },
+    {
+      "name": "deny-dangerous-activities",
+      "effect": "deny",
+      "principals": ["*"],
+      "actions": ["delete*", "admin*"],
+      "resources": ["*"]
+    }
+  ]
+}
+```
+
+## API Reference
+
+### `createPredicateInterceptors(options)`
+
+Creates the interceptor configuration object for `Worker.create()`.
+
+**Parameters:**
+
+- `options.authorityClient` (required): `AuthorityClient` - The Predicate Authority client instance
+- `options.principal` (optional): `string` - Principal ID (default: `"temporal-worker"`)
+- `options.tenantId` (optional): `string` - Tenant ID for multi-tenant setups
+- `options.sessionId` (optional): `string` - Session ID for request correlation
+- `options.resource` (optional): `string` - Resource identifier (default: `"temporal:activity"`)
+
+**Returns:** `WorkerInterceptors` - The interceptor configuration for Temporal Worker
+
+### `PredicateActivityInterceptor`
+
+The activity interceptor class. Usually you don't need to instantiate this directly - use `createPredicateInterceptors()` instead.
+
+### `PredicateAuthorizationError`
+
+Custom error thrown when authorization is denied.
+
+```typescript
+import { PredicateAuthorizationError } from "@predicatesystems/temporal";
+
+try {
+  await workflow.executeActivity("dangerousActivity", args);
+} catch (error) {
+  if (error instanceof PredicateAuthorizationError) {
+    console.log(`Denied: ${error.reason}`);
+    console.log(`Violated rule: ${error.violatedRule}`);
+  }
+}
+```
+
+## Error Handling
+
+When authorization is denied, the interceptor throws a `PredicateAuthorizationError`:
+
+```typescript
+import { ApplicationFailure } from "@temporalio/workflow";
+
+try {
+  await workflow.executeActivity("sensitiveActivity", args, {
+    startToCloseTimeout: "30s",
+  });
+} catch (error) {
+  if (error instanceof ApplicationFailure) {
+    // Check if it's a Predicate denial
+    if (error.message.includes("Predicate Zero-Trust Denial")) {
+      // Handle authorization denial
+      console.log("Activity was blocked by security policy");
+    }
+  }
+}
+```
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Build
+npm run build
+
+# Run tests
+npm test
+
+# Type checking
+npm run typecheck
+
+# Linting
+npm run lint
+```
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,127 @@
+import { Context } from '@temporalio/activity';
+import { ActivityInboundCallsInterceptor, ActivityExecuteInput, Next, WorkerInterceptors } from '@temporalio/worker';
+
+/**
+ * Predicate Authority interceptor for Temporal.io activities.
+ *
+ * This module provides a pre-execution security gate for all Temporal Activities,
+ * enforcing cryptographic authorization mandates before any activity code runs.
+ */
+
+/**
+ * Interface for the Predicate Authority client.
+ * This matches the AuthorityClient from @predicatesystems/authority.
+ */
+interface PredicateAuthorityClient {
+    authorize(request: PredicateAuthorizeRequest): Promise<PredicateAuthorizationResponse>;
+}
+/**
+ * Authorization request sent to the Predicate Authority sidecar.
+ */
+interface PredicateAuthorizeRequest {
+    principal: string;
+    action: string;
+    resource: string;
+    intent_hash?: string;
+    context?: Record<string, unknown>;
+    labels?: string[];
+}
+/**
+ * Authorization response from the Predicate Authority sidecar.
+ */
+interface PredicateAuthorizationResponse {
+    allowed: boolean;
+    reason: string;
+    mandate_id: string | null;
+    violated_rule: string | null;
+    missing_labels: string[];
+}
+/**
+ * Options for creating Predicate interceptors.
+ */
+interface PredicateInterceptorOptions {
+    /** The Predicate Authority client for authorization */
+    authorityClient: PredicateAuthorityClient;
+    /** Principal ID used for authorization requests (default: "temporal-worker") */
+    principal?: string;
+    /** Optional tenant ID for multi-tenant setups */
+    tenantId?: string;
+    /** Optional session ID for request correlation */
+    sessionId?: string;
+    /** Optional resource identifier (default: "temporal:activity") */
+    resource?: string;
+}
+/**
+ * Activity interceptor that enforces Predicate Authority authorization.
+ *
+ * This interceptor sits in the Temporal activity execution pipeline and ensures
+ * that every activity is authorized before execution. If authorization is denied,
+ * a PredicateAuthorizationError is thrown and the activity never executes.
+ */
+declare class PredicateActivityInterceptor implements ActivityInboundCallsInterceptor {
+    private readonly authorityClient;
+    private readonly principal;
+    private readonly tenantId;
+    private readonly sessionId;
+    private readonly resource;
+    private readonly activityType;
+    constructor(ctx: Context, options: PredicateInterceptorOptions);
+    /**
+     * Execute activity with Predicate Authority authorization check.
+     *
+     * This method intercepts the activity execution, extracts the activity type
+     * and arguments, and requests authorization from Predicate Authority.
+     * If denied, throws PredicateAuthorizationError. If approved, proceeds with execution.
+     */
+    execute(input: ActivityExecuteInput, next: Next<ActivityInboundCallsInterceptor, "execute">): Promise<unknown>;
+}
+/**
+ * Creates Temporal worker interceptors that enforce Predicate Authority authorization.
+ *
+ * @example
+ * ```typescript
+ * import { Worker } from "@temporalio/worker";
+ * import { AuthorityClient } from "@predicatesystems/authority";
+ * import { createPredicateInterceptors } from "@predicatesystems/temporal";
+ *
+ * const authorityClient = new AuthorityClient({
+ *   baseUrl: "http://127.0.0.1:8787",
+ * });
+ *
+ * const interceptors = createPredicateInterceptors({
+ *   authorityClient,
+ *   principal: "temporal-worker",
+ * });
+ *
+ * const worker = await Worker.create({
+ *   connection,
+ *   taskQueue: "my-task-queue",
+ *   workflowsPath: require.resolve("./workflows"),
+ *   activities,
+ *   interceptors,
+ * });
+ * ```
+ */
+declare function createPredicateInterceptors(options: PredicateInterceptorOptions): WorkerInterceptors;
+
+/**
+ * Error thrown when Predicate Authority denies an activity execution.
+ */
+declare class PredicateAuthorizationError extends Error {
+    /** The authorization reason code */
+    readonly reason: string;
+    /** The policy rule that caused the denial, if any */
+    readonly violatedRule: string | undefined;
+    /** Labels that were required but missing */
+    readonly missingLabels: readonly string[];
+    /** The activity type that was denied */
+    readonly activityType: string;
+    constructor(options: {
+        activityType: string;
+        reason: string;
+        violatedRule?: string | undefined;
+        missingLabels?: readonly string[];
+    });
+}
+
+export { PredicateActivityInterceptor, PredicateAuthorizationError, type PredicateInterceptorOptions, createPredicateInterceptors };

package/dist/index.d.ts

@@ -0,0 +1,127 @@
+import { Context } from '@temporalio/activity';
+import { ActivityInboundCallsInterceptor, ActivityExecuteInput, Next, WorkerInterceptors } from '@temporalio/worker';
+
+/**
+ * Predicate Authority interceptor for Temporal.io activities.
+ *
+ * This module provides a pre-execution security gate for all Temporal Activities,
+ * enforcing cryptographic authorization mandates before any activity code runs.
+ */
+
+/**
+ * Interface for the Predicate Authority client.
+ * This matches the AuthorityClient from @predicatesystems/authority.
+ */
+interface PredicateAuthorityClient {
+    authorize(request: PredicateAuthorizeRequest): Promise<PredicateAuthorizationResponse>;
+}
+/**
+ * Authorization request sent to the Predicate Authority sidecar.
+ */
+interface PredicateAuthorizeRequest {
+    principal: string;
+    action: string;
+    resource: string;
+    intent_hash?: string;
+    context?: Record<string, unknown>;
+    labels?: string[];
+}
+/**
+ * Authorization response from the Predicate Authority sidecar.
+ */
+interface PredicateAuthorizationResponse {
+    allowed: boolean;
+    reason: string;
+    mandate_id: string | null;
+    violated_rule: string | null;
+    missing_labels: string[];
+}
+/**
+ * Options for creating Predicate interceptors.
+ */
+interface PredicateInterceptorOptions {
+    /** The Predicate Authority client for authorization */
+    authorityClient: PredicateAuthorityClient;
+    /** Principal ID used for authorization requests (default: "temporal-worker") */
+    principal?: string;
+    /** Optional tenant ID for multi-tenant setups */
+    tenantId?: string;
+    /** Optional session ID for request correlation */
+    sessionId?: string;
+    /** Optional resource identifier (default: "temporal:activity") */
+    resource?: string;
+}
+/**
+ * Activity interceptor that enforces Predicate Authority authorization.
+ *
+ * This interceptor sits in the Temporal activity execution pipeline and ensures
+ * that every activity is authorized before execution. If authorization is denied,
+ * a PredicateAuthorizationError is thrown and the activity never executes.
+ */
+declare class PredicateActivityInterceptor implements ActivityInboundCallsInterceptor {
+    private readonly authorityClient;
+    private readonly principal;
+    private readonly tenantId;
+    private readonly sessionId;
+    private readonly resource;
+    private readonly activityType;
+    constructor(ctx: Context, options: PredicateInterceptorOptions);
+    /**
+     * Execute activity with Predicate Authority authorization check.
+     *
+     * This method intercepts the activity execution, extracts the activity type
+     * and arguments, and requests authorization from Predicate Authority.
+     * If denied, throws PredicateAuthorizationError. If approved, proceeds with execution.
+     */
+    execute(input: ActivityExecuteInput, next: Next<ActivityInboundCallsInterceptor, "execute">): Promise<unknown>;
+}
+/**
+ * Creates Temporal worker interceptors that enforce Predicate Authority authorization.
+ *
+ * @example
+ * ```typescript
+ * import { Worker } from "@temporalio/worker";
+ * import { AuthorityClient } from "@predicatesystems/authority";
+ * import { createPredicateInterceptors } from "@predicatesystems/temporal";
+ *
+ * const authorityClient = new AuthorityClient({
+ *   baseUrl: "http://127.0.0.1:8787",
+ * });
+ *
+ * const interceptors = createPredicateInterceptors({
+ *   authorityClient,
+ *   principal: "temporal-worker",
+ * });
+ *
+ * const worker = await Worker.create({
+ *   connection,
+ *   taskQueue: "my-task-queue",
+ *   workflowsPath: require.resolve("./workflows"),
+ *   activities,
+ *   interceptors,
+ * });
+ * ```
+ */
+declare function createPredicateInterceptors(options: PredicateInterceptorOptions): WorkerInterceptors;
+
+/**
+ * Error thrown when Predicate Authority denies an activity execution.
+ */
+declare class PredicateAuthorizationError extends Error {
+    /** The authorization reason code */
+    readonly reason: string;
+    /** The policy rule that caused the denial, if any */
+    readonly violatedRule: string | undefined;
+    /** Labels that were required but missing */
+    readonly missingLabels: readonly string[];
+    /** The activity type that was denied */
+    readonly activityType: string;
+    constructor(options: {
+        activityType: string;
+        reason: string;
+        violatedRule?: string | undefined;
+        missingLabels?: readonly string[];
+    });
+}
+
+export { PredicateActivityInterceptor, PredicateAuthorizationError, type PredicateInterceptorOptions, createPredicateInterceptors };

package/dist/index.js

@@ -0,0 +1,91 @@
+'use strict';
+
+var crypto = require('crypto');
+
+// src/interceptor.ts
+
+// src/errors.ts
+var PredicateAuthorizationError = class extends Error {
+  /** The authorization reason code */
+  reason;
+  /** The policy rule that caused the denial, if any */
+  violatedRule;
+  /** Labels that were required but missing */
+  missingLabels;
+  /** The activity type that was denied */
+  activityType;
+  constructor(options) {
+    const message = `Predicate Zero-Trust Denial: Activity '${options.activityType}' not authorized. Reason: ${options.reason}${options.violatedRule ? `, violated rule: ${options.violatedRule}` : ""}`;
+    super(message);
+    this.name = "PredicateAuthorizationError";
+    this.reason = options.reason;
+    this.violatedRule = options.violatedRule;
+    this.missingLabels = options.missingLabels ?? [];
+    this.activityType = options.activityType;
+  }
+};
+
+// src/interceptor.ts
+var PredicateActivityInterceptor = class {
+  authorityClient;
+  principal;
+  tenantId;
+  sessionId;
+  resource;
+  activityType;
+  constructor(ctx, options) {
+    this.authorityClient = options.authorityClient;
+    this.principal = options.principal ?? "temporal-worker";
+    this.tenantId = options.tenantId;
+    this.sessionId = options.sessionId;
+    this.resource = options.resource ?? "temporal:activity";
+    this.activityType = ctx.info.activityType;
+  }
+  /**
+   * Execute activity with Predicate Authority authorization check.
+   *
+   * This method intercepts the activity execution, extracts the activity type
+   * and arguments, and requests authorization from Predicate Authority.
+   * If denied, throws PredicateAuthorizationError. If approved, proceeds with execution.
+   */
+  async execute(input, next) {
+    const activityArgs = input.args;
+    const argsJson = JSON.stringify(activityArgs);
+    const argsHash = crypto.createHash("sha256").update(argsJson).digest("hex");
+    const request = {
+      principal: this.principal,
+      action: this.activityType,
+      resource: this.resource,
+      intent_hash: `ih_execute_${this.activityType.toLowerCase()}`,
+      context: {
+        state_hash: argsHash,
+        tenant_id: this.tenantId,
+        session_id: this.sessionId
+      }
+    };
+    const decision = await this.authorityClient.authorize(request);
+    if (!decision.allowed) {
+      throw new PredicateAuthorizationError({
+        activityType: this.activityType,
+        reason: decision.reason,
+        violatedRule: decision.violated_rule ?? void 0,
+        missingLabels: decision.missing_labels ?? []
+      });
+    }
+    return next(input);
+  }
+};
+function createPredicateInterceptors(options) {
+  const activityInterceptorFactory = (ctx) => ({
+    inbound: new PredicateActivityInterceptor(ctx, options)
+  });
+  return {
+    activity: [activityInterceptorFactory]
+  };
+}
+
+exports.PredicateActivityInterceptor = PredicateActivityInterceptor;
+exports.PredicateAuthorizationError = PredicateAuthorizationError;
+exports.createPredicateInterceptors = createPredicateInterceptors;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/errors.ts","../src/interceptor.ts"],"names":["createHash"],"mappings":"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","file":"index.js","sourcesContent":["/**\n * Error thrown when Predicate Authority denies an activity execution.\n */\nexport class PredicateAuthorizationError extends Error {\n  /** The authorization reason code */\n  public readonly reason: string;\n\n  /** The policy rule that caused the denial, if any */\n  public readonly violatedRule: string | undefined;\n\n  /** Labels that were required but missing */\n  public readonly missingLabels: readonly string[];\n\n  /** The activity type that was denied */\n  public readonly activityType: string;\n\n  constructor(options: {\n    activityType: string;\n    reason: string;\n    violatedRule?: string | undefined;\n    missingLabels?: readonly string[];\n  }) {\n    const message = `Predicate Zero-Trust Denial: Activity '${options.activityType}' not authorized. Reason: ${options.reason}${\n      options.violatedRule ? `, violated rule: ${options.violatedRule}` : \"\"\n    }`;\n    super(message);\n    this.name = \"PredicateAuthorizationError\";\n    this.reason = options.reason;\n    this.violatedRule = options.violatedRule;\n    this.missingLabels = options.missingLabels ?? [];\n    this.activityType = options.activityType;\n  }\n}\n","/**\n * Predicate Authority interceptor for Temporal.io activities.\n *\n * This module provides a pre-execution security gate for all Temporal Activities,\n * enforcing cryptographic authorization mandates before any activity code runs.\n */\n\nimport { createHash } from \"node:crypto\";\nimport type { Context } from \"@temporalio/activity\";\nimport type {\n  ActivityExecuteInput,\n  ActivityInboundCallsInterceptor,\n  ActivityInterceptorsFactory,\n  Next,\n  WorkerInterceptors,\n} from \"@temporalio/worker\";\nimport { PredicateAuthorizationError } from \"./errors.js\";\n\n/**\n * Interface for the Predicate Authority client.\n * This matches the AuthorityClient from @predicatesystems/authority.\n */\nexport interface PredicateAuthorityClient {\n  authorize(request: PredicateAuthorizeRequest): Promise<PredicateAuthorizationResponse>;\n}\n\n/**\n * Authorization request sent to the Predicate Authority sidecar.\n */\nexport interface PredicateAuthorizeRequest {\n  principal: string;\n  action: string;\n  resource: string;\n  intent_hash?: string;\n  context?: Record<string, unknown>;\n  labels?: string[];\n}\n\n/**\n * Authorization response from the Predicate Authority sidecar.\n */\nexport interface PredicateAuthorizationResponse {\n  allowed: boolean;\n  reason: string;\n  mandate_id: string | null;\n  violated_rule: string | null;\n  missing_labels: string[];\n}\n\n/**\n * Options for creating Predicate interceptors.\n */\nexport interface PredicateInterceptorOptions {\n  /** The Predicate Authority client for authorization */\n  authorityClient: PredicateAuthorityClient;\n\n  /** Principal ID used for authorization requests (default: \"temporal-worker\") */\n  principal?: string;\n\n  /** Optional tenant ID for multi-tenant setups */\n  tenantId?: string;\n\n  /** Optional session ID for request correlation */\n  sessionId?: string;\n\n  /** Optional resource identifier (default: \"temporal:activity\") */\n  resource?: string;\n}\n\n/**\n * Activity interceptor that enforces Predicate Authority authorization.\n *\n * This interceptor sits in the Temporal activity execution pipeline and ensures\n * that every activity is authorized before execution. If authorization is denied,\n * a PredicateAuthorizationError is thrown and the activity never executes.\n */\nexport class PredicateActivityInterceptor implements ActivityInboundCallsInterceptor {\n  private readonly authorityClient: PredicateAuthorityClient;\n  private readonly principal: string;\n  private readonly tenantId: string | undefined;\n  private readonly sessionId: string | undefined;\n  private readonly resource: string;\n  private readonly activityType: string;\n\n  constructor(ctx: Context, options: PredicateInterceptorOptions) {\n    this.authorityClient = options.authorityClient;\n    this.principal = options.principal ?? \"temporal-worker\";\n    this.tenantId = options.tenantId;\n    this.sessionId = options.sessionId;\n    this.resource = options.resource ?? \"temporal:activity\";\n    this.activityType = ctx.info.activityType;\n  }\n\n  /**\n   * Execute activity with Predicate Authority authorization check.\n   *\n   * This method intercepts the activity execution, extracts the activity type\n   * and arguments, and requests authorization from Predicate Authority.\n   * If denied, throws PredicateAuthorizationError. If approved, proceeds with execution.\n   */\n  async execute(\n    input: ActivityExecuteInput,\n    next: Next<ActivityInboundCallsInterceptor, \"execute\">\n  ): Promise<unknown> {\n    const activityArgs = input.args;\n\n    // Hash the arguments for state evidence\n    const argsJson = JSON.stringify(activityArgs);\n    const argsHash = createHash(\"sha256\").update(argsJson).digest(\"hex\");\n\n    const request: PredicateAuthorizeRequest = {\n      principal: this.principal,\n      action: this.activityType,\n      resource: this.resource,\n      intent_hash: `ih_execute_${this.activityType.toLowerCase()}`,\n      context: {\n        state_hash: argsHash,\n        tenant_id: this.tenantId,\n        session_id: this.sessionId,\n      },\n    };\n\n    const decision = await this.authorityClient.authorize(request);\n\n    if (!decision.allowed) {\n      throw new PredicateAuthorizationError({\n        activityType: this.activityType,\n        reason: decision.reason,\n        violatedRule: decision.violated_rule ?? undefined,\n        missingLabels: decision.missing_labels ?? [],\n      });\n    }\n\n    return next(input);\n  }\n}\n\n/**\n * Creates Temporal worker interceptors that enforce Predicate Authority authorization.\n *\n * @example\n * ```typescript\n * import { Worker } from \"@temporalio/worker\";\n * import { AuthorityClient } from \"@predicatesystems/authority\";\n * import { createPredicateInterceptors } from \"@predicatesystems/temporal\";\n *\n * const authorityClient = new AuthorityClient({\n *   baseUrl: \"http://127.0.0.1:8787\",\n * });\n *\n * const interceptors = createPredicateInterceptors({\n *   authorityClient,\n *   principal: \"temporal-worker\",\n * });\n *\n * const worker = await Worker.create({\n *   connection,\n *   taskQueue: \"my-task-queue\",\n *   workflowsPath: require.resolve(\"./workflows\"),\n *   activities,\n *   interceptors,\n * });\n * ```\n */\nexport function createPredicateInterceptors(\n  options: PredicateInterceptorOptions\n): WorkerInterceptors {\n  const activityInterceptorFactory: ActivityInterceptorsFactory = (ctx) => ({\n    inbound: new PredicateActivityInterceptor(ctx, options),\n  });\n\n  return {\n    activity: [activityInterceptorFactory],\n  };\n}\n"]}

package/dist/index.mjs

@@ -0,0 +1,87 @@
+import { createHash } from 'crypto';
+
+// src/interceptor.ts
+
+// src/errors.ts
+var PredicateAuthorizationError = class extends Error {
+  /** The authorization reason code */
+  reason;
+  /** The policy rule that caused the denial, if any */
+  violatedRule;
+  /** Labels that were required but missing */
+  missingLabels;
+  /** The activity type that was denied */
+  activityType;
+  constructor(options) {
+    const message = `Predicate Zero-Trust Denial: Activity '${options.activityType}' not authorized. Reason: ${options.reason}${options.violatedRule ? `, violated rule: ${options.violatedRule}` : ""}`;
+    super(message);
+    this.name = "PredicateAuthorizationError";
+    this.reason = options.reason;
+    this.violatedRule = options.violatedRule;
+    this.missingLabels = options.missingLabels ?? [];
+    this.activityType = options.activityType;
+  }
+};
+
+// src/interceptor.ts
+var PredicateActivityInterceptor = class {
+  authorityClient;
+  principal;
+  tenantId;
+  sessionId;
+  resource;
+  activityType;
+  constructor(ctx, options) {
+    this.authorityClient = options.authorityClient;
+    this.principal = options.principal ?? "temporal-worker";
+    this.tenantId = options.tenantId;
+    this.sessionId = options.sessionId;
+    this.resource = options.resource ?? "temporal:activity";
+    this.activityType = ctx.info.activityType;
+  }
+  /**
+   * Execute activity with Predicate Authority authorization check.
+   *
+   * This method intercepts the activity execution, extracts the activity type
+   * and arguments, and requests authorization from Predicate Authority.
+   * If denied, throws PredicateAuthorizationError. If approved, proceeds with execution.
+   */
+  async execute(input, next) {
+    const activityArgs = input.args;
+    const argsJson = JSON.stringify(activityArgs);
+    const argsHash = createHash("sha256").update(argsJson).digest("hex");
+    const request = {
+      principal: this.principal,
+      action: this.activityType,
+      resource: this.resource,
+      intent_hash: `ih_execute_${this.activityType.toLowerCase()}`,
+      context: {
+        state_hash: argsHash,
+        tenant_id: this.tenantId,
+        session_id: this.sessionId
+      }
+    };
+    const decision = await this.authorityClient.authorize(request);
+    if (!decision.allowed) {
+      throw new PredicateAuthorizationError({
+        activityType: this.activityType,
+        reason: decision.reason,
+        violatedRule: decision.violated_rule ?? void 0,
+        missingLabels: decision.missing_labels ?? []
+      });
+    }
+    return next(input);
+  }
+};
+function createPredicateInterceptors(options) {
+  const activityInterceptorFactory = (ctx) => ({
+    inbound: new PredicateActivityInterceptor(ctx, options)
+  });
+  return {
+    activity: [activityInterceptorFactory]
+  };
+}
+
+export { PredicateActivityInterceptor, PredicateAuthorizationError, createPredicateInterceptors };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/errors.ts","../src/interceptor.ts"],"names":[],"mappings":"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","file":"index.mjs","sourcesContent":["/**\n * Error thrown when Predicate Authority denies an activity execution.\n */\nexport class PredicateAuthorizationError extends Error {\n  /** The authorization reason code */\n  public readonly reason: string;\n\n  /** The policy rule that caused the denial, if any */\n  public readonly violatedRule: string | undefined;\n\n  /** Labels that were required but missing */\n  public readonly missingLabels: readonly string[];\n\n  /** The activity type that was denied */\n  public readonly activityType: string;\n\n  constructor(options: {\n    activityType: string;\n    reason: string;\n    violatedRule?: string | undefined;\n    missingLabels?: readonly string[];\n  }) {\n    const message = `Predicate Zero-Trust Denial: Activity '${options.activityType}' not authorized. Reason: ${options.reason}${\n      options.violatedRule ? `, violated rule: ${options.violatedRule}` : \"\"\n    }`;\n    super(message);\n    this.name = \"PredicateAuthorizationError\";\n    this.reason = options.reason;\n    this.violatedRule = options.violatedRule;\n    this.missingLabels = options.missingLabels ?? [];\n    this.activityType = options.activityType;\n  }\n}\n","/**\n * Predicate Authority interceptor for Temporal.io activities.\n *\n * This module provides a pre-execution security gate for all Temporal Activities,\n * enforcing cryptographic authorization mandates before any activity code runs.\n */\n\nimport { createHash } from \"node:crypto\";\nimport type { Context } from \"@temporalio/activity\";\nimport type {\n  ActivityExecuteInput,\n  ActivityInboundCallsInterceptor,\n  ActivityInterceptorsFactory,\n  Next,\n  WorkerInterceptors,\n} from \"@temporalio/worker\";\nimport { PredicateAuthorizationError } from \"./errors.js\";\n\n/**\n * Interface for the Predicate Authority client.\n * This matches the AuthorityClient from @predicatesystems/authority.\n */\nexport interface PredicateAuthorityClient {\n  authorize(request: PredicateAuthorizeRequest): Promise<PredicateAuthorizationResponse>;\n}\n\n/**\n * Authorization request sent to the Predicate Authority sidecar.\n */\nexport interface PredicateAuthorizeRequest {\n  principal: string;\n  action: string;\n  resource: string;\n  intent_hash?: string;\n  context?: Record<string, unknown>;\n  labels?: string[];\n}\n\n/**\n * Authorization response from the Predicate Authority sidecar.\n */\nexport interface PredicateAuthorizationResponse {\n  allowed: boolean;\n  reason: string;\n  mandate_id: string | null;\n  violated_rule: string | null;\n  missing_labels: string[];\n}\n\n/**\n * Options for creating Predicate interceptors.\n */\nexport interface PredicateInterceptorOptions {\n  /** The Predicate Authority client for authorization */\n  authorityClient: PredicateAuthorityClient;\n\n  /** Principal ID used for authorization requests (default: \"temporal-worker\") */\n  principal?: string;\n\n  /** Optional tenant ID for multi-tenant setups */\n  tenantId?: string;\n\n  /** Optional session ID for request correlation */\n  sessionId?: string;\n\n  /** Optional resource identifier (default: \"temporal:activity\") */\n  resource?: string;\n}\n\n/**\n * Activity interceptor that enforces Predicate Authority authorization.\n *\n * This interceptor sits in the Temporal activity execution pipeline and ensures\n * that every activity is authorized before execution. If authorization is denied,\n * a PredicateAuthorizationError is thrown and the activity never executes.\n */\nexport class PredicateActivityInterceptor implements ActivityInboundCallsInterceptor {\n  private readonly authorityClient: PredicateAuthorityClient;\n  private readonly principal: string;\n  private readonly tenantId: string | undefined;\n  private readonly sessionId: string | undefined;\n  private readonly resource: string;\n  private readonly activityType: string;\n\n  constructor(ctx: Context, options: PredicateInterceptorOptions) {\n    this.authorityClient = options.authorityClient;\n    this.principal = options.principal ?? \"temporal-worker\";\n    this.tenantId = options.tenantId;\n    this.sessionId = options.sessionId;\n    this.resource = options.resource ?? \"temporal:activity\";\n    this.activityType = ctx.info.activityType;\n  }\n\n  /**\n   * Execute activity with Predicate Authority authorization check.\n   *\n   * This method intercepts the activity execution, extracts the activity type\n   * and arguments, and requests authorization from Predicate Authority.\n   * If denied, throws PredicateAuthorizationError. If approved, proceeds with execution.\n   */\n  async execute(\n    input: ActivityExecuteInput,\n    next: Next<ActivityInboundCallsInterceptor, \"execute\">\n  ): Promise<unknown> {\n    const activityArgs = input.args;\n\n    // Hash the arguments for state evidence\n    const argsJson = JSON.stringify(activityArgs);\n    const argsHash = createHash(\"sha256\").update(argsJson).digest(\"hex\");\n\n    const request: PredicateAuthorizeRequest = {\n      principal: this.principal,\n      action: this.activityType,\n      resource: this.resource,\n      intent_hash: `ih_execute_${this.activityType.toLowerCase()}`,\n      context: {\n        state_hash: argsHash,\n        tenant_id: this.tenantId,\n        session_id: this.sessionId,\n      },\n    };\n\n    const decision = await this.authorityClient.authorize(request);\n\n    if (!decision.allowed) {\n      throw new PredicateAuthorizationError({\n        activityType: this.activityType,\n        reason: decision.reason,\n        violatedRule: decision.violated_rule ?? undefined,\n        missingLabels: decision.missing_labels ?? [],\n      });\n    }\n\n    return next(input);\n  }\n}\n\n/**\n * Creates Temporal worker interceptors that enforce Predicate Authority authorization.\n *\n * @example\n * ```typescript\n * import { Worker } from \"@temporalio/worker\";\n * import { AuthorityClient } from \"@predicatesystems/authority\";\n * import { createPredicateInterceptors } from \"@predicatesystems/temporal\";\n *\n * const authorityClient = new AuthorityClient({\n *   baseUrl: \"http://127.0.0.1:8787\",\n * });\n *\n * const interceptors = createPredicateInterceptors({\n *   authorityClient,\n *   principal: \"temporal-worker\",\n * });\n *\n * const worker = await Worker.create({\n *   connection,\n *   taskQueue: \"my-task-queue\",\n *   workflowsPath: require.resolve(\"./workflows\"),\n *   activities,\n *   interceptors,\n * });\n * ```\n */\nexport function createPredicateInterceptors(\n  options: PredicateInterceptorOptions\n): WorkerInterceptors {\n  const activityInterceptorFactory: ActivityInterceptorsFactory = (ctx) => ({\n    inbound: new PredicateActivityInterceptor(ctx, options),\n  });\n\n  return {\n    activity: [activityInterceptorFactory],\n  };\n}\n"]}

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@predicatesystems/temporal",
+  "version": "0.1.0",
+  "description": "Temporal.io Worker Interceptor for Predicate Authority Zero-Trust authorization",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check src tests",
+    "lint:fix": "biome check --write src tests",
+    "format": "biome format --write src tests",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "temporal",
+    "temporalio",
+    "authorization",
+    "zero-trust",
+    "security",
+    "ai-agents",
+    "predicate-authority",
+    "interceptor"
+  ],
+  "author": "Predicate Systems <hello@predicatesystems.dev>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/PredicateSystems/temporal-predicate-typescript.git"
+  },
+  "bugs": {
+    "url": "https://github.com/PredicateSystems/temporal-predicate-typescript/issues"
+  },
+  "homepage": "https://github.com/PredicateSystems/temporal-predicate-typescript#readme",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "peerDependencies": {
+    "@predicatesystems/authority": ">=0.1.0",
+    "@temporalio/worker": ">=1.9.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^1.5.0",
+    "@predicatesystems/authority": "^0.3.0",
+    "@temporalio/worker": "^1.11.0",
+    "@types/node": "^20.11.0",
+    "@vitest/coverage-v8": "^1.2.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0",
+    "vitest": "^1.2.0"
+  }
+}