@erichll/pi-auto-review 0.1.1

package/src/broker/index.ts

@@ -0,0 +1,29 @@
+export { BoundaryApprovalBroker } from "./broker.ts";
+export { DenialCircuitBreaker } from "./circuit-breaker.ts";
+export { boundaryRequestHash, OneShotGrantStore } from "./grants.ts";
+export { RecentDenialStore } from "./overrides.ts";
+export {
+  BOUNDARY_BROKER_SERVICE_KEY,
+  getBoundaryBroker,
+  publishBoundaryBroker,
+} from "./service.ts";
+export type {
+  BoundaryApprovalBrokerService,
+} from "./service.ts";
+export type {
+  BoundaryAuditEvent,
+  BoundaryDecision,
+  BoundaryGrant,
+  BoundaryHardDeny,
+  BoundaryRequest,
+  BoundaryReview,
+  BoundaryReviewContext,
+  BoundaryReviewer,
+  BoundaryReviewerContext,
+  BoundaryRiskLevel,
+  BoundarySource,
+  BoundarySurface,
+  BoundaryUserOverride,
+  RecentBoundaryDenial,
+  UserAuthorization,
+} from "./types.ts";

package/src/broker/overrides.ts

@@ -0,0 +1,120 @@
+import { boundaryRequestHash } from "./grants.ts";
+import type {
+  BoundaryRequest,
+  BoundaryReview,
+  BoundaryReviewContext,
+  BoundaryUserOverride,
+  RecentBoundaryDenial,
+} from "./types.ts";
+
+type PendingOverride = {
+  originalRequestId: string;
+  approvedAt: number;
+};
+
+export class RecentDenialStore {
+  readonly #denials: RecentBoundaryDenial[] = [];
+  readonly #pending = new Map<string, PendingOverride>();
+  readonly #used = new Set<string>();
+  readonly #limit: number;
+  readonly #now: () => number;
+  readonly #overrideTtlMs: number;
+
+  constructor(
+    limit = 10,
+    now: () => number = Date.now,
+    overrideTtlMs = 60_000,
+  ) {
+    this.#limit = limit;
+    this.#now = now;
+    this.#overrideTtlMs = overrideTtlMs;
+  }
+
+  record(
+    request: BoundaryRequest,
+    context: BoundaryReviewContext,
+    review: BoundaryReview,
+  ): void {
+    const requestHash = boundaryRequestHash(request);
+    const kept = this.#denials.filter(
+      (denial) =>
+        !(
+          denial.sessionId === context.sessionId &&
+          denial.scopeKey === context.scopeKey &&
+          denial.requestHash === requestHash
+        ),
+    );
+    this.#denials.splice(0, this.#denials.length, ...kept);
+    this.#denials.unshift({
+      requestId: request.id,
+      requestHash,
+      request: structuredClone(request),
+      review: { ...review },
+      sessionId: context.sessionId,
+      scopeKey: context.scopeKey,
+      deniedAt: this.#now(),
+    });
+    if (this.#denials.length > this.#limit) {
+      this.#denials.length = this.#limit;
+    }
+  }
+
+  list(sessionId: string): RecentBoundaryDenial[] {
+    return this.#denials
+      .filter((denial) => denial.sessionId === sessionId)
+      .map((denial) => structuredClone(denial));
+  }
+
+  authorize(
+    requestId: string,
+    sessionId: string,
+  ): RecentBoundaryDenial | undefined {
+    const denial = this.#denials.find(
+      (entry) =>
+        entry.requestId === requestId &&
+        entry.sessionId === sessionId,
+    );
+    if (!denial) return;
+    const key = this.key(sessionId, denial.requestHash);
+    const pending = this.#pending.get(key);
+    if (
+      pending &&
+      this.#now() - pending.approvedAt > this.#overrideTtlMs
+    ) {
+      this.#pending.delete(key);
+    }
+    if (this.#used.has(key) || this.#pending.has(key)) return;
+    this.#pending.set(key, {
+      originalRequestId: denial.requestId,
+      approvedAt: this.#now(),
+    });
+    return structuredClone(denial);
+  }
+
+  consume(
+    request: BoundaryRequest,
+    context: BoundaryReviewContext,
+  ): BoundaryUserOverride | undefined {
+    const requestHash = boundaryRequestHash(request);
+    const key = this.key(context.sessionId, requestHash);
+    const pending = this.#pending.get(key);
+    if (!pending) return;
+    this.#pending.delete(key);
+    if (this.#now() - pending.approvedAt > this.#overrideTtlMs) return;
+    this.#used.add(key);
+    return { ...pending };
+  }
+
+  clear(): void {
+    this.#denials.length = 0;
+    this.#pending.clear();
+    this.#used.clear();
+  }
+
+  private key(
+    sessionId: string,
+    requestHash: string,
+  ): string {
+    return `${sessionId}\u0000${requestHash}`;
+  }
+}

package/src/broker/service.ts

@@ -0,0 +1,50 @@
+import type { BoundaryApprovalBroker } from "./broker.ts";
+import type {
+  BoundaryDecision,
+  BoundaryRequest,
+  BoundaryReviewContext,
+} from "./types.ts";
+
+export const BOUNDARY_BROKER_SERVICE_KEY = Symbol.for(
+  "pi-auto-review:boundary-approval-broker",
+);
+
+export type BoundaryApprovalBrokerService = {
+  review(
+    request: BoundaryRequest,
+    context: BoundaryReviewContext,
+  ): Promise<BoundaryDecision>;
+  consumeGrant(
+    request: BoundaryRequest,
+    sessionId: string,
+    token: string,
+  ): boolean;
+};
+
+export function publishBoundaryBroker(
+  broker: BoundaryApprovalBroker,
+): () => void {
+  const target = globalThis as Record<symbol, unknown>;
+  if (target[BOUNDARY_BROKER_SERVICE_KEY]) {
+    throw new Error("pi-auto-review boundary broker is already published");
+  }
+  const service: BoundaryApprovalBrokerService = {
+    review: (request, context) => broker.review(request, context),
+    consumeGrant: (request, sessionId, token) =>
+      broker.consumeGrant(request, sessionId, token),
+  };
+  target[BOUNDARY_BROKER_SERVICE_KEY] = service;
+  return () => {
+    if (target[BOUNDARY_BROKER_SERVICE_KEY] === service) {
+      delete target[BOUNDARY_BROKER_SERVICE_KEY];
+    }
+  };
+}
+
+export function getBoundaryBroker():
+  | BoundaryApprovalBrokerService
+  | undefined {
+  return (globalThis as Record<symbol, unknown>)[
+    BOUNDARY_BROKER_SERVICE_KEY
+  ] as BoundaryApprovalBrokerService | undefined;
+}

package/src/broker/types.ts

@@ -0,0 +1,118 @@
+export type BoundarySurface =
+  | "command"
+  | "filesystem-read"
+  | "filesystem-write"
+  | "network"
+  | "mcp"
+  | "skill"
+  | (string & {});
+
+export type BoundarySource =
+  | "permission-system"
+  | "landstrip"
+  | (string & {});
+
+export type BoundaryRequest = {
+  id: string;
+  source: BoundarySource;
+  surface: BoundarySurface;
+  operation: string;
+  cwd: string;
+  command?: string;
+  path?: string;
+  resolvedPath?: string;
+  destination?: string;
+  toolCallId?: string;
+  toolName?: string;
+  skillName?: string;
+  toolInputPreview?: string;
+  agentName?: string;
+  matchedPolicy?: {
+    decision: "ask";
+    rule?: string;
+  };
+};
+
+export type BoundaryRiskLevel = "low" | "medium" | "high" | "critical";
+export type UserAuthorization = "unknown" | "low" | "medium" | "high";
+
+export type BoundaryReview = {
+  outcome: "allow" | "deny" | "defer";
+  riskLevel: BoundaryRiskLevel;
+  userAuthorization: UserAuthorization;
+  rationale: string;
+};
+
+export type BoundaryGrant = {
+  token: string;
+  requestHash: string;
+  sessionId: string;
+  expiresAt: number;
+  usesRemaining: 1;
+};
+
+export type BoundaryDecision =
+  | {
+      kind: "allow";
+      review: BoundaryReview;
+      grant?: BoundaryGrant;
+    }
+  | {
+      kind: "deny";
+      review: BoundaryReview;
+      circuitBreakerTripped: boolean;
+    }
+  | {
+      kind: "defer";
+      review: BoundaryReview;
+    };
+
+export type BoundaryReviewContext = {
+  sessionId: string;
+  scopeKey: string;
+  issueGrant?: boolean;
+};
+
+export type BoundaryUserOverride = {
+  originalRequestId: string;
+  approvedAt: number;
+};
+
+export type BoundaryReviewerContext = {
+  userOverride?: BoundaryUserOverride;
+};
+
+export type RecentBoundaryDenial = {
+  requestId: string;
+  requestHash: string;
+  request: BoundaryRequest;
+  review: BoundaryReview;
+  sessionId: string;
+  scopeKey: string;
+  deniedAt: number;
+};
+
+export type BoundaryAuditEvent = {
+  type:
+    | "hard_deny"
+    | "review_decision"
+    | "review_failure"
+    | "circuit_breaker"
+    | "grant_issued"
+    | "grant_consumed"
+    | "grant_rejected"
+    | "override_authorized"
+    | "override_consumed";
+  requestId: string;
+  surface: string;
+  details: Record<string, unknown>;
+};
+
+export type BoundaryReviewer = (
+  request: BoundaryRequest,
+  context?: BoundaryReviewerContext,
+) => Promise<BoundaryReview>;
+
+export type BoundaryHardDeny = (
+  request: BoundaryRequest,
+) => { rule: string; reason: string } | undefined;

package/src/config.json

@@ -0,0 +1,12 @@
+{
+  "model": "cliproxyapi/codex-auto-review",
+  "reasoning": "medium",
+  "timeoutMs": 45000,
+  "maxTokens": 1600,
+  "retries": 1,
+  "maxUserTranscriptTokens": 1200,
+  "maxToolTranscriptTokens": 1200,
+  "maxRelevantResultTokens": 800,
+  "failureMode": "deny",
+  "grantTtlMs": 60000
+}