@mortz.prk/opencode-auto-mode 0.1.3 → 1.0.0

package/src/traces.ts

@@ -0,0 +1,84 @@
+import { randomBytes } from "node:crypto";
+import type { AuditRecord } from "./audit.js";
+import type { OtlpOptions } from "./otlp.js";
+import type { StageResult } from "./reviewer.js";
+
+export interface ClassifierAttempt {
+  index: number;
+  type: string;
+  model?: string;
+  startedAt: number;
+  durationMs: number;
+  result: StageResult;
+}
+
+export interface ReviewTrace {
+  traceID: string;
+  spanID: string;
+  attempts: ClassifierAttempt[];
+  finish(record: AuditRecord): void;
+}
+
+const attribute = (key: string, value: string | number) => ({
+  key,
+  value: typeof value === "number" ? { intValue: String(value) } : { stringValue: value },
+});
+const nano = (ms: number) => String(BigInt(Math.trunc(ms)) * 1_000_000n);
+
+export function tracesUrl(base: string): string {
+  const url = new URL(base);
+  if (!["http:", "https:"].includes(url.protocol) || url.username || url.password) throw new Error("Invalid OTLP endpoint");
+  url.pathname = url.pathname.replace(/\/v1\/(?:logs|traces)\/?$/, "").replace(/\/+$/, "") + "/v1/traces";
+  return url.href;
+}
+
+function headers(raw: string | undefined): Record<string, string> {
+  return Object.fromEntries((raw ?? "").split(",").flatMap((pair) => {
+    const index = pair.indexOf("=");
+    return index > 0 ? [[pair.slice(0, index).trim(), pair.slice(index + 1).trim()]] : [];
+  }));
+}
+
+export function createTraceExporter(setting: boolean | OtlpOptions | undefined, env: NodeJS.ProcessEnv = process.env) {
+  if (setting === undefined || setting === false) return undefined;
+  const options = setting === true ? {} : setting;
+  const base = options.endpoint ?? env.OPENCODE_OTLP_ENDPOINT ?? env.OTEL_EXPORTER_OTLP_ENDPOINT;
+  if (!base) return undefined;
+  let url: string;
+  try { url = tracesUrl(base); } catch { return undefined; }
+  const requestHeaders = { "content-type": "application/json", ...headers(env.OTEL_EXPORTER_OTLP_HEADERS), ...headers(env.OPENCODE_OTLP_HEADERS), ...options.headers };
+  return {
+    begin(startedAt: number): ReviewTrace {
+      const traceID = randomBytes(16).toString("hex");
+      const spanID = randomBytes(8).toString("hex");
+      const attempts: ClassifierAttempt[] = [];
+      return {
+        traceID, spanID, attempts,
+        finish(record) {
+          const shared = [attribute("review.id", record.reviewID), attribute("session.id", record.sessionID)];
+          const spans = [{
+            traceId: traceID, spanId: spanID, name: "auto_mode.review", kind: 1,
+            startTimeUnixNano: nano(startedAt), endTimeUnixNano: nano(startedAt + record.durationMs),
+            attributes: [...shared, attribute("action", record.action), attribute("agent", record.agent ?? ""),
+              attribute("decision", record.decision), attribute("stage", record.stage)],
+            status: { code: record.error ? 2 : 1 },
+          }, ...attempts.map((attempt) => ({
+            traceId: traceID, spanId: randomBytes(8).toString("hex"), parentSpanId: spanID,
+            name: "auto_mode.classifier", kind: 1,
+            startTimeUnixNano: nano(attempt.startedAt), endTimeUnixNano: nano(attempt.startedAt + attempt.durationMs),
+            attributes: [...shared, attribute("classifier.index", attempt.index), attribute("classifier.type", attempt.type),
+              attribute("model", attempt.model ?? ""), attribute("decision", attempt.result.decision)],
+            status: { code: 1 },
+          }))];
+          const body = JSON.stringify({ resourceSpans: [{
+            resource: { attributes: [attribute("service.name", "opencode-auto-mode")] },
+            scopeSpans: [{ scope: { name: "opencode-auto-mode" }, spans }],
+          }] });
+          // Match log export: best effort, independent of permission delivery.
+          fetch(url, { method: "POST", headers: requestHeaders, body, redirect: "error",
+            signal: AbortSignal.timeout(Math.min(options.timeoutMs ?? 3_000, 10_000)) }).catch(() => {});
+        },
+      };
+    },
+  };
+}

package/src/transcript.ts

@@ -55,6 +55,23 @@ function formatTool(tool: ToolEntry): string {
   return detail ? `${tool.name} ${detail}` : tool.name;
 }
 
+export interface ReviewContext { transcript: string; complete: boolean }
+
+export function extractReviewContext(messages: unknown[]): ReviewContext {
+  const supported = messages.every((message) => {
+    const record = asRecord(message);
+    if (record?.type !== "user") return true;
+    // These attachments carry evidence that the text-only reviewer cannot see.
+    return userText(message) !== undefined && ["files", "skills", "agents"].every((key) =>
+      record[key] === undefined || (Array.isArray(record[key]) && record[key].length === 0));
+  });
+  const transcript = extractTranscript(messages);
+  return {
+    transcript,
+    complete: supported && transcript.startsWith("User messages") && !transcript.includes("…"),
+  };
+}
+
 export function extractTranscript(messages: unknown[]): string {
   const entries: { role: "user" | "tool"; text: string }[] = [];
   for (const message of messages) {

package/src/tui-state.ts

@@ -0,0 +1,7 @@
+import type { DecisionRecord } from "./state.js";
+
+export function isReviewing(records: Record<string, DecisionRecord>, sessionID: string | undefined, now = Date.now()): boolean {
+  if (!sessionID) return false;
+  return Object.values(records).some((record) => record.sessionID === sessionID &&
+    record.decision === "reviewing" && now - record.at >= 0 && now - record.at < 90_000);
+}

package/src/tui.tsx

@@ -1,320 +1,33 @@
 /** @jsxImportSource @opentui/solid */
-import { createMemo, createSignal, Show, type JSX } from "solid-js";
+import { createSignal, Show } from "solid-js";
 import { Plugin } from "@opencode/plugin/tui";
-import type { Context } from "@opencode/plugin/tui/context";
-import type { ResolvedTheme } from "@opencode/theme/tui";
 import { readDecisions } from "./state.js";
+import { isReviewing } from "./tui-state.js";
 
 const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-const MAX_RESOURCE = 48;
-const POLL_MS = 1_000;
-const STALE_MS = 90_000;
-
-type Pending = {
-  requestID: string;
-  sessionID: string;
-  action: string;
-  resource: string;
-  at: number;
-  escalated: boolean;
-};
-
-function str(value: unknown, fallback: string): string {
-  return typeof value === "string" && value.trim() ? value.trim() : fallback;
-}
-
-function truncate(value: string, max: number): string {
-  return value.length > max ? value.slice(0, max - 1) + "…" : value;
-}
-
-// `ctx.data.session.list()` is unreliable across betas: on 0.0.0-beta-17823
-// the host's session store memo never invalidates, so iterating sessions to
-// find pending permissions sees an empty list forever. Instead the badge is
-// fed by permission events plus the server plugin's decision file: tier-3
-// reviews run inside the evaluate hook BEFORE a permission request exists,
-// so "reviewing" records (synthetic IDs) create spinner entries, and the
-// permission.asked event that follows an escalation adopts the matching
-// entry so its spinner time carries over.
-function Badge(props: {
-  pending: () => Pending | undefined;
-  answer: (reply: "once" | "reject") => Promise<void>;
-  allowKey: string;
-  denyKey: string;
-  keymap: Pick<Context["keymap"], "layer">;
-  theme: () => ResolvedTheme;
-}): JSX.Element {
-  const theme = props.theme();
-
-  props.keymap.layer(() => ({
-    mode: "base",
-    commands: [
-      {
-        id: "auto-mode.allow",
-        title: "Allow pending permission",
-        group: "Auto-mode",
-        palette: true,
-        bind: props.allowKey,
-        // Only real, escalated requests can be answered — during review no
-        // server-side permission request exists yet.
-        enabled: () => props.pending()?.escalated === true,
-        run: () => {
-          void props.answer("once");
-        },
-      },
-      {
-        id: "auto-mode.deny",
-        title: "Deny pending permission",
-        group: "Auto-mode",
-        palette: true,
-        bind: props.denyKey,
-        enabled: () => props.pending()?.escalated === true,
-        run: () => {
-          void props.answer("reject");
-        },
-      },
-    ],
-  }));
-
-  const thinking = createMemo(() => {
-    const p = props.pending();
-    return p !== undefined && !p.escalated;
-  });
-  const label = createMemo(() => (thinking() ? "reviewing" : "needs your approval"));
-
-  // The glyph comes from opentui's intrinsic <spinner>, not our own timer:
-  // npm installs can split solid-js into two instances (the plugin's exact
-  // pin vs @opentui/solid's peer pin), which freezes timer-driven signal
-  // renders. The spinner element animates on its own renderable, so the
-  // badge works regardless of how dependencies resolve.
-  return (
-    <box flexDirection="row" gap={1}>
-      <spinner frames={SPINNER_FRAMES} interval={120} color={theme.text.feedback.warning.base} />
-      <text fg={theme.text.feedback.warning.base}>auto-mode {label()}</text>
-    </box>
-  );
-}
 
 export default Plugin.define({
   id: "opencode-auto-mode",
   setup: async (ctx) => {
-    const options = ctx.options as Record<string, unknown>;
-    const keybinds = (options.keybinds ?? {}) as Record<string, unknown>;
-    const allowKey = str(keybinds.allow, "ctrl+alt+a");
-    const denyKey = str(keybinds.deny, "ctrl+alt+d");
-
-    // Own pending list, fed by events. Keeping it locally (instead of reading
-    // the host's session store) makes the badge independent of host store
-    // behavior across betas.
-    const [pending, setPending] = createSignal<Pending[]>([]);
-    const firstSeen = new Map<string, number>();
-
-    const addPending = (data: {
-      id: string;
-      sessionID: string;
-      action: string;
-      resources: readonly string[];
-    }) => {
-      if (pending().some((p) => p.requestID === data.id)) return;
-      // An asked event means the server plugin's review already finished with
-      // ASK. Adopt a matching in-review entry so its spinner duration carries
-      // over instead of restarting the badge from scratch.
-      const inReview = pending().find(
-        (p) => !p.escalated && p.sessionID === data.sessionID && p.action === data.action,
-      );
-      if (inReview) {
-        firstSeen.delete(inReview.requestID);
-        setPending((prev) =>
-          prev.map((p) =>
-            p === inReview ? { ...p, requestID: data.id, escalated: true } : p,
-          ),
-        );
-        firstSeen.set(data.id, inReview.at);
-        return;
-      }
-      const at = firstSeen.get(data.id) ?? Date.now();
-      firstSeen.set(data.id, at);
-      setPending((prev) => [
-        ...prev,
-        {
-          requestID: data.id,
-          sessionID: data.sessionID,
-          action: data.action,
-          resource: truncate(data.resources.join(" ") || data.action, MAX_RESOURCE),
-          at,
-          escalated: true,
-        },
-      ]);
-    };
-
-    const removePending = (requestID: string) => {
-      firstSeen.delete(requestID);
-      setPending((prev) => prev.filter((p) => p.requestID !== requestID));
-    };
-
-    // Primary channel: the host data bus. Some host versions forward only a
-    // subset of event types, so the raw server stream below is the fallback;
-    // handlers dedupe by request ID.
-    const unsubs = [
-      ctx.data.on("permission.asked", (event) => addPending(event.data)),
-      ctx.data.on("permission.replied", (event) => removePending(event.data.requestID)),
-    ];
-
-    // Fallback channel: the raw server event stream, with reconnection.
-    const abort = new AbortController();
-    const runStream = async () => {
-      while (!abort.signal.aborted) {
-        try {
-          for await (const event of ctx.client.event.subscribe({ signal: abort.signal })) {
-            if (event.type === "permission.asked") addPending(event.data);
-            else if (event.type === "permission.replied") removePending(event.data.requestID);
-          }
-        } catch {
-          // fall through to reconnect
-        }
-        if (abort.signal.aborted) return;
-        await new Promise((resolve) => setTimeout(resolve, 2000));
-      }
+    if (ctx.options.tui === false) return;
+    const [reviewing, setReviewing] = createSignal(false);
+    const update = () => {
+      const route = ctx.ui.router.current();
+      setReviewing(isReviewing(readDecisions(), route.type === "session" ? route.sessionID : undefined));
     };
-    void runStream();
-
-    // Reconcile with the server plugin's decision file:
-    // - "reviewing" records create spinner entries (they precede any event,
-    //   since the evaluate hook runs before the request is published)
-    // - "ask" escalates the entry, "allow"/"deny" resolves it
-    // - entries that outlived every record and the review window are pruned
-    const poll = setInterval(() => {
-      snapshotView();
-      const decisions = readDecisions();
-      const now = Date.now();
-      let next = pending();
-      let dirty = false;
-
-      for (const [reviewID, rec] of Object.entries(decisions)) {
-        if (rec.decision !== "reviewing") continue;
-        if (next.some((p) => p.requestID === reviewID)) continue;
-        if (now - rec.at >= STALE_MS) continue;
-        firstSeen.set(reviewID, rec.at);
-        next = [
-          ...next,
-          {
-            requestID: reviewID,
-            sessionID: rec.sessionID,
-            action: rec.action ?? "",
-            resource: truncate(
-              (rec.resources ?? []).join(" ") || rec.action || "",
-              MAX_RESOURCE,
-            ),
-            at: rec.at,
-            escalated: false,
-          },
-        ];
-        dirty = true;
-      }
-
-      const reconciled: Pending[] = [];
-      for (const p of next) {
-        const record = decisions[p.requestID];
-        if (record?.decision === "allow" || record?.decision === "deny") {
-          firstSeen.delete(p.requestID);
-          dirty = true;
-          continue;
-        }
-        if (record?.decision === "ask" && !p.escalated) {
-          reconciled.push({ ...p, escalated: true });
-          dirty = true;
-          continue;
-        }
-        if (!record && now - p.at >= STALE_MS) {
-          firstSeen.delete(p.requestID);
-          dirty = true;
-          continue;
-        }
-        reconciled.push(p);
-      }
-      if (dirty) setPending(reconciled);
-    }, POLL_MS);
-
-    // View scoping: decision records live in a machine-global file (and on
-    // shared servers permission events are global too), so without filtering
-    // every open TUI would badge other TUIs' reviews. Router + tabs state is
-    // client-local — a foreign session is never the current route nor an open
-    // tab here — which discriminates both separate-server and shared-server
-    // setups. Snapshotted on the existing poll tick (1s granularity is fine
-    // for a status badge) instead of relying on host reactivity.
-    const [visibleIDs, setVisibleIDs] = createSignal<ReadonlySet<string>>(new Set());
-    const snapshotView = () => {
-      const ids = new Set<string>();
-      try {
-        if (ctx.ui.tabs.enabled()) {
-          for (const tab of ctx.ui.tabs.list()) ids.add(tab.sessionID);
-        }
-      } catch {
-        // tabs unavailable — route only
-      }
-      try {
-        const route = ctx.ui.router.current();
-        if (route.type === "session") ids.add(route.sessionID);
-      } catch {
-        // router unavailable — tabs only
-      }
-      const key = [...ids].sort().join(",");
-      const prev = [...visibleIDs()].sort().join(",");
-      if (key !== prev) setVisibleIDs(ids);
-    };
-    snapshotView();
-
-    const mostRecent = createMemo(() => {
-      const visible = visibleIDs();
-      const requests = pending().filter((p) => visible.has(p.sessionID));
-      return requests.length > 0 ? requests[requests.length - 1] : undefined;
-    });
-
-    const answer = async (reply: "once" | "reject") => {
-      const pendingRequest = mostRecent();
-      if (!pendingRequest) return;
-      try {
-        await ctx.client.permission.reply({
-          sessionID: pendingRequest.sessionID,
-          requestID: pendingRequest.requestID,
-          decision: reply,
-        });
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        ctx.ui.toast.show({
-          variant: "error",
-          title: "Auto-mode",
-          message: `Failed to reply: ${message}`,
-          duration: 4000,
-        });
-      }
-    };
-
-    // Top-right overlay, above the permission dialog (which covers the bottom
-    // bar). Only visible while this TUI has a session with a pending review:
-    // spinner while reviewing, ⚠ when it needs the user.
-    const disposeBadge = ctx.ui.slot({
+    update();
+    const poll = setInterval(update, 250);
+    const dispose = ctx.ui.slot({
       append: "app",
       render: () => (
-        <Show when={mostRecent() !== undefined}>
-          <box position="absolute" top={0} right={0} zIndex={10_000}>
-            <Badge
-              pending={mostRecent}
-              answer={answer}
-              allowKey={allowKey}
-              denyKey={denyKey}
-              keymap={ctx.keymap}
-              theme={() => ctx.theme}
-            />
+        <Show when={reviewing()}>
+          <box position="absolute" top={0} right={0} zIndex={10_000} flexDirection="row" gap={1}>
+            <spinner frames={SPINNER_FRAMES} interval={120} color={ctx.theme.text.feedback.warning.base} />
+            <text fg={ctx.theme.text.feedback.warning.base}>auto-mode reviewing</text>
           </box>
         </Show>
       ),
     });
-
-    return () => {
-      for (const unsub of unsubs) unsub();
-      abort.abort();
-      clearInterval(poll);
-      disposeBadge();
-    };
+    return () => { clearInterval(poll); dispose(); };
   },
 });

package/src/providers.ts

@@ -1,103 +0,0 @@
-import { object, localEndpoint, type ClassifierStage } from "./config.js";
-import { buildReviewPrompt, type PermissionRequest, type ReviewResult, type Decision } from "./reviewer.js";
-import type { ReviewPolicy } from "./policy.js";
-
-export type ProviderStage = Extract<ClassifierStage, { type: "jev" | "openai-decision" | "laya" }>;
-const choices = {
-  allow: "The whole action is safe and authorized by the user for this exact scope.",
-  deny: "The action violates the supplied policy or attempts to bypass a block.",
-  ask: "Authorization, evidence, or impact is uncertain; the human must decide.",
-};
-const MAX_BYTES = 65_536;
-
-function probability(value: unknown): value is number {
-  return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1;
-}
-
-function answer(value: unknown, stage: ProviderStage): ReviewResult | undefined {
-  if (!object(value) || value.type !== "choice" || typeof value.choice !== "string" || !Object.hasOwn(choices, value.choice) ||
-      !probability(value.confidence) || !object(value.probabilities))
-    throw new Error("Invalid decision response");
-  const entries = Object.entries(value.probabilities);
-  if (entries.length !== 3 || entries.some(([key, value]) => !Object.hasOwn(choices, key) || !probability(value)))
-    throw new Error("Invalid decision probabilities");
-  const probabilities = value.probabilities as Record<Decision, number>;
-  if (Math.abs(Object.values(probabilities).reduce((a, b) => a + b, 0) - 1) > 0.01 ||
-      probabilities[value.choice as Decision] < Math.max(...Object.values(probabilities)))
-    throw new Error("Inconsistent decision probabilities");
-  if (value.choice === "ask") return { decision: "ask", reason: `${stage.type} requested human review` };
-  if (value.confidence < (stage.minConfidence ?? 0.9) || probabilities[value.choice as Decision] < (stage.minConfidence ?? 0.9))
-    return undefined;
-  return { decision: value.choice as Decision, reason: `${stage.type} decision (confidence ${value.confidence})` };
-}
-
-async function readJSON(response: Response): Promise<unknown> {
-  if (!response.ok || !response.body) throw new Error("Decision provider failed");
-  const reader = response.body.getReader();
-  const chunks: Uint8Array[] = [];
-  let size = 0;
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      size += value.length;
-      if (size > MAX_BYTES) throw new Error("Decision response too large");
-      chunks.push(value);
-    }
-    return JSON.parse(Buffer.concat(chunks).toString("utf8"));
-  } finally {
-    await reader.cancel().catch(() => {});
-    reader.releaseLock();
-  }
-}
-
-export async function providerDecision(
-  stage: ProviderStage,
-  request: PermissionRequest,
-  policy: ReviewPolicy,
-  fetcher: typeof fetch = fetch,
-): Promise<ReviewResult | undefined> {
-  try {
-    const openai = stage.type === "openai-decision";
-    const endpoint = stage.type === "laya" ? localEndpoint(stage.endpoint ?? "http://127.0.0.1:8000/v1/systemone") :
-      openai ? "https://api.openai.com/v1/decisions" : "https://api.typesafe.ai/v1/systemone";
-    const key = process.env[stage.apiKeyEnv ?? (openai ? "OPENAI_API_KEY" : stage.type === "jev" ? "TYPESAFE_API_KEY" : "LAYA_API_KEY")];
-    if (stage.type !== "laya" && !key) throw new Error("Missing decision provider credentials");
-    const instructions = buildReviewPrompt(request, policy);
-    const body = openai ? {
-      model: stage.model ?? "gpt-6-luna",
-      input: JSON.stringify(request),
-      questions: [{ name: "permission", type: "choice", instructions,
-        choices: Object.entries(choices).map(([value, description]) => ({ value, description })) }],
-    } : {
-      ...(stage.type === "jev" ? { model: stage.model ?? "jev-latest" } : stage.model ? { model: stage.model } : {}),
-      state: request,
-      questions: { permission: { type: "choice", instructions, criteria: choices } },
-    };
-    const payload = JSON.stringify(body);
-    if (Buffer.byteLength(payload) > MAX_BYTES) throw new Error("Decision request too large");
-    const response = await fetcher(endpoint, {
-      method: "POST", redirect: "error", signal: AbortSignal.timeout(stage.timeoutMs ?? 10_000),
-      headers: { "Content-Type": "application/json", ...(key ? { Authorization: `Bearer ${key}` } : {}) },
-      body: payload,
-    });
-    const parsed = await readJSON(response);
-    if (!object(parsed)) throw new Error("Invalid decision response");
-    if (!openai) return answer(object(parsed.answers) ? parsed.answers.permission : undefined, stage);
-    if (!Array.isArray(parsed.answers) || parsed.answers.length !== 1 || !object(parsed.answers[0]) ||
-        parsed.answers[0].name !== "permission") throw new Error("Invalid OpenAI answer");
-    const selected = parsed.answers[0];
-    if (selected.type === "refusal") return { decision: "ask", reason: "OpenAI declined the decision" };
-    if (!Array.isArray(selected.probabilities) || selected.probabilities.length !== 3)
-      throw new Error("Invalid OpenAI probabilities");
-    const distribution: Record<string, unknown> = {};
-    for (const entry of selected.probabilities) {
-      if (!object(entry) || typeof entry.value !== "string" || !Object.hasOwn(choices, entry.value) ||
-          Object.hasOwn(distribution, entry.value)) throw new Error("Invalid OpenAI probability entry");
-      distribution[entry.value] = entry.probability;
-    }
-    return answer({ ...selected, probabilities: distribution }, stage);
-  } catch {
-    return { decision: "ask", reason: `${stage.type} unavailable or returned an invalid decision` };
-  }
-}

package/src/rules-worker.ts

@@ -1,38 +0,0 @@
-import { parentPort, workerData } from "node:worker_threads";
-import { compileExpression, type RuleBindings } from "./rules.js";
-import type { UserRule } from "./config.js";
-import { shellWords } from "./shell.js";
-
-const { rules, resources, bindings, hasResources } = workerData as {
-  rules: UserRule[]; resources: string[]; bindings: RuleBindings; hasResources: boolean;
-};
-function evaluate() {
-  const results = rules.map(() => ({ any: false, coverage: hasResources ? resources.map(() => false) : [] }));
-  for (const decision of ["deny", "ask", "allow"]) {
-    let failed = false;
-    for (const [index, rule] of rules.entries()) {
-      if (rule.decision !== decision) continue;
-      try {
-        const predicate = compileExpression(rule.expression);
-        const matches = resources.map(() => false);
-        for (const [resourceIndex, resource] of resources.entries()) {
-          try {
-            const words = bindings.action === "shell" ? shellWords(resource) ?? [] : [];
-            const result = predicate({ ...bindings, resource, command: words[0] ?? "", args: words.slice(1) });
-            if (typeof result !== "boolean") throw new Error("CEL rules must return a boolean");
-            matches[resourceIndex] = result;
-            if (result && decision !== "allow") {
-              results[index] = { any: true, coverage: hasResources ? matches : [] };
-              return results;
-            }
-          } catch { failed = true; }
-        }
-        results[index] = { any: matches.some(Boolean), coverage: hasResources ? matches : [] };
-      } catch { failed = true; }
-    }
-    if (failed) return null;
-  }
-  return results;
-}
-
-parentPort!.postMessage(evaluate());

package/src/rules.ts

@@ -1,79 +0,0 @@
-import { celEnv, CelScalar, listType, parse, plan } from "@bufbuild/cel";
-import { Worker } from "node:worker_threads";
-import type { UserRule } from "./config.js";
-import type { PermissionRequest } from "./reviewer.js";
-
-const environment = celEnv({ variables: {
-  action: CelScalar.STRING, resource: CelScalar.STRING, agent: CelScalar.STRING,
-  projectDir: CelScalar.STRING, isDelegation: CelScalar.BOOL,
-  command: CelScalar.STRING, args: listType(CelScalar.STRING),
-} });
-let activeWorkers = 0;
-
-export function compileExpression(expression: string) {
-  if (typeof expression !== "string" || !expression.trim() || expression.length > 4096)
-    throw new Error("Invalid CEL expression");
-  const parsed = parse(expression);
-  type Expr = NonNullable<typeof parsed.expr>;
-  const pending: { expr: Expr; depth: number }[] = [];
-  if (parsed.expr) pending.push({ expr: parsed.expr, depth: 1 });
-  let count = 0;
-  while (pending.length) {
-    const { expr, depth } = pending.pop()!;
-    if (++count > 512 || depth > 32) throw new Error("CEL expression is too complex");
-    const kind = expr.exprKind;
-    const children: Expr[] = [];
-    if (kind.case === "comprehensionExpr") throw new Error("CEL collection macros are disabled");
-    if (kind.case === "callExpr") {
-      children.push(...kind.value.args);
-      if (kind.value.target) children.push(kind.value.target);
-    } else if (kind.case === "selectExpr" && kind.value.operand) children.push(kind.value.operand);
-    else if (kind.case === "listExpr") children.push(...kind.value.elements);
-    else if (kind.case === "structExpr") {
-      for (const entry of kind.value.entries) {
-        if (entry.keyKind.case === "mapKey") children.push(entry.keyKind.value);
-        if (entry.value) children.push(entry.value);
-      }
-    }
-    for (const child of children) pending.push({ expr: child, depth: depth + 1 });
-  }
-  return plan(environment, parsed);
-}
-
-export type RuleMatch = { rule: UserRule; any: boolean; coverage: boolean[] };
-export type RuleBindings = { action: string; agent: string; projectDir: string; isDelegation: boolean };
-
-export async function evaluateRules(rules: UserRule[], request: PermissionRequest): Promise<RuleMatch[]> {
-  if (!rules.length) return [];
-  const resources = request.resources.length ? request.resources : [""];
-  const bindings: RuleBindings = { action: request.action, agent: request.agent ?? "",
-    projectDir: request.projectDir ?? "", isDelegation: request.isDelegation === true };
-  const strings = [...resources, bindings.action, bindings.agent, bindings.projectDir];
-  if (resources.length > 256 || rules.length * resources.length > 4096 ||
-      strings.some((value) => typeof value !== "string" || value.length > 4096) ||
-      strings.reduce((sum, value) => sum + Buffer.byteLength(value), 0) > 65_536)
-    throw new Error("CEL request exceeds evaluation limits");
-  if (activeWorkers >= 4) throw new Error("CEL evaluator is busy");
-  const worker = new Worker(new URL("./rules-worker.ts", import.meta.url), {
-    workerData: { rules, resources, bindings, hasResources: request.resources.length > 0 },
-  });
-  activeWorkers++;
-  try {
-    const matches = await new Promise<{ any: boolean; coverage: boolean[] }[]>((resolve, reject) => {
-      const timer = setTimeout(() => reject(new Error("CEL evaluation timed out")), 1000);
-      const fail = () => { clearTimeout(timer); reject(new Error("CEL evaluation failed")); };
-      worker.once("error", fail);
-      worker.once("exit", fail);
-      worker.once("message", (value: unknown) => {
-        clearTimeout(timer);
-        if (!Array.isArray(value) || value.length !== rules.length || value.some((match) =>
-          !match || typeof match.any !== "boolean" || !Array.isArray(match.coverage) ||
-          match.coverage.length !== request.resources.length || match.coverage.some((item: unknown) => typeof item !== "boolean"))) { fail(); return; }
-        resolve(value);
-      });
-    });
-    return matches.map((match, index) => ({ ...match, rule: rules[index] }));
-  } finally {
-    try { await worker.terminate(); } finally { activeWorkers--; }
-  }
-}