failproofai 1.0.7-beta.1 → 1.0.7

package/.next/standalone/app/settings/jev-panel.tsx

@@ -1,469 +0,0 @@
-"use client";
-
-/**
- * The Jev panel on /settings — the dashboard's half of `failproofai jev setup`.
- *
- * ## What it is for
- *
- * Jev is the optional second evaluation tier. It is on when, and only when, a
- * valid `~/.failproofai/jev.json` exists; without it the hook path is byte for
- * byte what it was before. So this panel has two jobs, in this order:
- *
- *   1. say whether it is on, where it sends requests, in which mode, how much
- *      of the enabled policy set it is allowed to clear, and — once it has run
- *      — how often it fell back to the regex engine. A panel that only took
- *      input would leave "is this thing working" unanswerable from the
- *      dashboard.
- *   2. take the endpoint and the token.
- *
- * It is a full-width cell in the same hairline console as the scheduled-audit
- * panel, using the same tokens, the same `.btn-press` action and the same
- * `toast()` on success. No new colour and no new control that did not already
- * exist on this page, except a `<select>` — five providers do not fit a switch.
- *
- * ## The token is write-only
- *
- * The field is always blank on load, whatever is stored. `JevSettingsView`
- * carries a presence flag and at most the last four characters, so the panel
- * can say "configured, ending 3f2a" and nothing more; the value itself never
- * leaves the machine's filesystem. Leaving the field empty on save KEEPS the
- * key where it is — the stored one, or the environment's for a config that takes
- * it from there — which the server decides, not this component.
- *
- * The stored MODEL is shown the same way when it does not look like a model id,
- * for the same reason: it is the one routing field someone can paste a key into.
- * The panel gets a `JevModelView`, never the string, so there is nothing here to
- * leak even by accident. It is display-only — the form does not offer the field,
- * and a save leaves whatever is stored alone.
- *
- * Client-side validation here is a convenience only. Every rule — the URL
- * scheme, plain http being refused outside shadow mode, cloudflare's account id
- * — is enforced server-side by the same `validateJevConfig` the loader runs.
- */
-
-import { useCallback, useEffect, useRef, useState, type ReactNode } from "react";
-import {
-  getJevSettingsAction,
-  type JevModelView,
-  type JevSettingsView,
-} from "@/app/actions/get-jev-config";
-import {
-  removeJevConfigAction,
-  saveJevConfigAction,
-} from "@/app/actions/update-jev-config";
-import { toast } from "@/app/components/toast";
-
-const PROVIDERS = [
-  { value: "typesafe", label: "typesafe" },
-  { value: "openrouter", label: "openrouter" },
-  { value: "vercel", label: "vercel ai gateway" },
-  { value: "cloudflare", label: "cloudflare workers ai" },
-  { value: "custom", label: "custom endpoint" },
-] as const;
-
-const MODES = [
-  { value: "enforce", label: "enforce — jev's verdict counts" },
-  { value: "shadow", label: "shadow — log only, regex decides" },
-] as const;
-
-/** "24h" / "7d" / "30m", for the stats window. */
-function fmtWindow(ms: number): string {
-  const h = ms / 3_600_000;
-  if (Number.isInteger(h) && h >= 1) return h % 24 === 0 ? `${h / 24}d` : `${h}h`;
-  return `${Math.max(1, Math.round(ms / 60_000))}m`;
-}
-
-/** A rate as a whole percent. 0.0417 → "4%". */
-function fmtRate(rate: number): string {
-  return `${Math.round(rate * 100)}%`;
-}
-
-/**
- * The model row. `withheld` is the case worth having a row for at all: the file
- * holds something in that slot that does not look like a model id, which is
- * what a key pasted one field off looks like, so it is described and not
- * printed — and the server never sent it here to print. The loader's own reason
- * and its fix are already on the page above, in `view.problem`.
- */
-function fmtModel(model: JevModelView): string {
-  switch (model.kind) {
-    case "id":
-      return model.id;
-    case "withheld":
-      return "set to something that is not a model id — not shown here, in case it is a key";
-    default:
-      return "the provider's default";
-  }
-}
-
-interface FormState {
-  provider: string;
-  baseUrl: string;
-  accountId: string;
-  mode: string;
-}
-
-function formFrom(view: JevSettingsView): FormState {
-  return {
-    provider: view.provider ?? "typesafe",
-    baseUrl: view.baseUrl,
-    accountId: view.accountId,
-    mode: view.mode,
-  };
-}
-
-/** One labelled control, laid out like the interval row above it. */
-function Field({
-  id,
-  label,
-  hint,
-  children,
-}: {
-  id: string;
-  label: string;
-  hint?: string;
-  children: ReactNode;
-}) {
-  return (
-    <div className="set-field">
-      <label className="set-field-label" htmlFor={id}>
-        {label}
-      </label>
-      {children}
-      {hint ? <span className="set-hint">{hint}</span> : null}
-    </div>
-  );
-}
-
-export default function JevPanel({ initial }: { initial: JevSettingsView | null }) {
-  const [view, setView] = useState<JevSettingsView | null>(initial);
-  const [form, setForm] = useState<FormState>(
-    initial ? formFrom(initial) : { provider: "typesafe", baseUrl: "", accountId: "", mode: "enforce" },
-  );
-  const [token, setToken] = useState("");
-  const [busy, setBusy] = useState(false);
-  const [problem, setProblem] = useState<string | null>(null);
-  /**
-   * The server's `needsToken`: the one refusal whose remedy is this field, so it
-   * is marked rather than leaving the person to match the message to a control.
-   * The refusals that no token can settle deliberately do not set it.
-   */
-  const [needsToken, setNeedsToken] = useState(false);
-  const mounted = useRef(true);
-  /**
-   * Whether the user has touched the form since the last read. A focus refresh
-   * must not overwrite a half-typed endpoint with what is still on disk — the
-   * page re-reads on every `visibilitychange`, which includes the tab hide that
-   * happens when somebody alt-tabs to their password manager mid-edit.
-   */
-  const dirty = useRef(false);
-
-  const reload = useCallback(async () => {
-    try {
-      const next = await getJevSettingsAction();
-      if (!mounted.current) return;
-      setView(next);
-      if (!dirty.current) setForm(formFrom(next));
-    } catch {
-      // Leave what is on screen: it describes real machine state, and blanking
-      // it would report something less true than what is already there.
-    }
-  }, []);
-
-  useEffect(() => {
-    mounted.current = true;
-    void reload();
-    return () => {
-      mounted.current = false;
-    };
-  }, [reload]);
-
-  useEffect(() => {
-    // Same reason as the scheduled-audit panel: `failproofai jev setup` in a
-    // terminal changes the same file, and a page left open would otherwise keep
-    // showing the old state until it was reloaded by hand.
-    const onFocus = () => void reload();
-    window.addEventListener("focus", onFocus);
-    document.addEventListener("visibilitychange", onFocus);
-    return () => {
-      window.removeEventListener("focus", onFocus);
-      document.removeEventListener("visibilitychange", onFocus);
-    };
-  }, [reload]);
-
-  const set = useCallback(<K extends keyof FormState>(key: K, value: FormState[K]) => {
-    dirty.current = true;
-    setForm((f) => ({ ...f, [key]: value }));
-  }, []);
-
-  const onSave = useCallback(async () => {
-    setBusy(true);
-    setProblem(null);
-    try {
-      // The form does not offer a model, so it says nothing about one: the
-      // server keeps a stored model when the provider is unchanged, and drops it
-      // for the new provider's default when it is not — the same rule `jev setup`
-      // applies. `JevConfigInput` has no model field for this to get wrong.
-      const res = await saveJevConfigAction({
-        provider: form.provider,
-        baseUrl: form.baseUrl,
-        accountId: form.accountId,
-        mode: form.mode,
-        token,
-      });
-      if (!res.ok) {
-        setProblem(res.problem);
-        setNeedsToken(res.needsToken === true);
-        return;
-      }
-      dirty.current = false;
-      setNeedsToken(false);
-      setToken("");
-      setView(res.view);
-      setForm(formFrom(res.view));
-      toast(res.view.on ? "jev is on." : "saved.");
-    } catch {
-      setProblem("could not save that.");
-    } finally {
-      setBusy(false);
-    }
-  }, [form, token]);
-
-  const onRemove = useCallback(async () => {
-    setBusy(true);
-    setProblem(null);
-    setNeedsToken(false);
-    try {
-      const res = await removeJevConfigAction();
-      if (!res.ok) {
-        setProblem(res.problem);
-        return;
-      }
-      dirty.current = false;
-      setToken("");
-      setView(res.view);
-      setForm(formFrom(res.view));
-      toast("jev is off. hooks run the regex policies.");
-    } catch {
-      setProblem("could not turn that off.");
-    } finally {
-      setBusy(false);
-    }
-  }, []);
-
-  const configured = view !== null && view.status !== "absent";
-  const stored = view?.token;
-  const tokenHint = needsToken
-    ? "needed for this save — type the token for this endpoint"
-    : stored
-      ? stored.source === "env"
-        ? "configured, read from the environment — leave blank to keep it"
-        : stored.hint
-          ? `configured, ending ${stored.hint} — leave blank to keep it`
-          : "configured — leave blank to keep it"
-      : // The file names the environment as the key's source and the variable is
-        // unset in this process. Leaving the field blank keeps that arrangement,
-        // which is not the same thing as "there is no key" — the endpoint and the
-        // mode are editable from here without one.
-        view?.status === "key-missing"
-        ? "read from the environment, which is not set in this shell — leave blank to keep it that way"
-        : "sent as a bearer token; stored owner-only at 0600";
-
-  return (
-    <div className="set-cell set-jev">
-      <h2 className="set-cell-title">jev · semantic evaluation</h2>
-
-      <div className="set-row set-row-main">
-        <div className="set-row-copy">
-          <span className={view?.on ? "set-strong" : "set-dim"}>
-            {view === null
-              ? "reading…"
-              : view.on
-                ? `on. every judged command is also asked of ${view.provider}.`
-                : "off. hooks run the regex policies exactly as before."}
-          </span>
-          <span className="set-dim">
-            {view?.on
-              ? view.mode === "shadow"
-                ? "shadow: jev's answers are logged, the regex result is what gets enforced."
-                : "enforce: jev's answers can clear a reviewable deny."
-              : "a second opinion on the commands the regex policies flag. needs your own endpoint and token."}
-          </span>
-        </div>
-      </div>
-
-      {view && configured && (
-        <dl className="set-how-list">
-          {view.endpoint && (
-            <div className="set-how-row">
-              <dt className="set-how-label">endpoint</dt>
-              <dd className="set-how-body">{view.endpoint}</dd>
-            </div>
-          )}
-          <div className="set-how-row">
-            <dt className="set-how-label">model</dt>
-            <dd className="set-how-body">{fmtModel(view.model)}</dd>
-          </div>
-          <div className="set-how-row">
-            <dt className="set-how-label">token</dt>
-            <dd className="set-how-body">
-              {stored
-                ? stored.source === "env"
-                  ? "from FAILPROOFAI_JEV_API_KEY"
-                  : stored.hint
-                    ? `configured, ending ${stored.hint}`
-                    : "configured"
-                : "none stored"}
-            </dd>
-          </div>
-          {view.permissions && (
-            <div className="set-how-row">
-              <dt className="set-how-label">file</dt>
-              <dd className="set-how-body">
-                {`${view.path} · ${view.permissions}`}
-              </dd>
-            </div>
-          )}
-          {view.reviewable && (
-            <div className="set-how-row">
-              <dt className="set-how-label">reviewable</dt>
-              {/* The count, in the server's words — the same sentence
-                  `failproofai jev status` prints, because the two surfaces must
-                  not disagree about what Jev is allowed to clear. */}
-              <dd className="set-how-body">{view.reviewable.summary}</dd>
-            </div>
-          )}
-          {view.stats && view.stats.total > 0 && (
-            <div className="set-how-row">
-              <dt className="set-how-label">fallbacks</dt>
-              {/* One string, not an interpolated fragment: a sentence split
-                  across text nodes is a sentence a screen reader and a test both
-                  have to reassemble. */}
-              <dd className="set-how-body">
-                {`${fmtRate(view.stats.fallbackRate)} of ${view.stats.total} calls in the last ${fmtWindow(view.stats.windowMs)} fell back to the regex engine.`}
-              </dd>
-            </div>
-          )}
-        </dl>
-      )}
-
-      {view?.problem && (
-        <p className="set-warn">
-          {view.problem}
-          {view.fix ? ` — ${view.fix}` : ""}
-        </p>
-      )}
-
-      {/* Jev is on, answering, and cannot clear a single verdict. Nothing else
-          on this page shows it: a policy set with no authority marks behaves
-          exactly like a healthy one until you notice that nothing is ever
-          cleared. The server sends the cause and the remedy together. */}
-      {view?.reviewable?.problem && <p className="set-warn">{view.reviewable.problem}</p>}
-
-      <div className="set-rule" />
-
-      <div className="set-jev-fields">
-        <Field id="jev-provider" label="provider">
-          <select
-            id="jev-provider"
-            className="set-select"
-            value={form.provider}
-            disabled={busy}
-            onChange={(e) => set("provider", e.target.value)}
-          >
-            {PROVIDERS.map((p) => (
-              <option key={p.value} value={p.value}>
-                {p.label}
-              </option>
-            ))}
-          </select>
-        </Field>
-
-        <Field
-          id="jev-url"
-          label="endpoint url"
-          hint={
-            form.provider === "custom"
-              ? "required — https, or http to localhost in shadow mode"
-              : "leave blank for the provider's own api"
-          }
-        >
-          <input
-            id="jev-url"
-            type="text"
-            className="set-text"
-            inputMode="url"
-            autoComplete="off"
-            spellCheck={false}
-            placeholder={form.provider === "custom" ? "https://…" : "the provider's own api"}
-            value={form.baseUrl}
-            disabled={busy}
-            onChange={(e) => set("baseUrl", e.target.value)}
-          />
-        </Field>
-
-        {form.provider === "cloudflare" && (
-          <Field id="jev-account" label="account id" hint="32 lowercase hex characters">
-            <input
-              id="jev-account"
-              type="text"
-              className="set-text"
-              autoComplete="off"
-              spellCheck={false}
-              value={form.accountId}
-              disabled={busy}
-              onChange={(e) => set("accountId", e.target.value)}
-            />
-          </Field>
-        )}
-
-        <Field id="jev-token" label="token" hint={tokenHint}>
-          <input
-            id="jev-token"
-            type="password"
-            className="set-text"
-            autoComplete="off"
-            spellCheck={false}
-            placeholder={stored ? "•••• kept" : ""}
-            value={token}
-            disabled={busy}
-            aria-invalid={needsToken || undefined}
-            onChange={(e) => {
-              dirty.current = true;
-              setToken(e.target.value);
-            }}
-          />
-        </Field>
-
-        <Field id="jev-mode" label="mode">
-          <select
-            id="jev-mode"
-            className="set-select"
-            value={form.mode}
-            disabled={busy}
-            onChange={(e) => set("mode", e.target.value)}
-          >
-            {MODES.map((m) => (
-              <option key={m.value} value={m.value}>
-                {m.label}
-              </option>
-            ))}
-          </select>
-        </Field>
-      </div>
-
-      {problem && <p className="set-warn">{problem}</p>}
-
-      <div className="set-actions set-jev-actions">
-        <button type="button" className="btn btn-press" disabled={busy} onClick={() => void onSave()}>
-          {busy ? "[ saving… ]" : configured ? "[ save changes ]" : "[ turn jev on ]"}
-        </button>
-        {configured && (
-          <button type="button" className="set-link" disabled={busy} onClick={() => void onRemove()}>
-            turn jev off
-          </button>
-        )}
-      </div>
-    </div>
-  );
-}

package/src/hooks/effective-reviewers.ts

@@ -1,79 +0,0 @@
-/**
- * The semantic checks a `reviewedBy` may name ON THIS MACHINE.
- *
- * ## Why this is not simply `SEMANTIC_REVIEWER_NAMES`
- *
- * A pack that declares its own `semantic` entries replaces the compiled-in
- * `SEMANTIC_POLICIES` wholesale (`semantic/pack-policies.ts`). So on that
- * machine the sixteen builtin names are checks that will never be asked, and the
- * pack's own names are the only ones that will — while
- * `resolvePolicyAuthority`, judging against the builtin set, would read the
- * pack's `reviewedBy: ["its-own-check"]` as naming a check "this build does not
- * have" and downgrade the policy to `hard` with nothing but a warning in the
- * hook log. That is a rewritten policy set arriving with its reviewability
- * quietly removed: the deny half of the two-tier evaluator working exactly as
- * documented while the clearing half cannot fire once — the failure
- * `policy-reviewability.ts` was written to make audible, reintroduced one layer
- * down.
- *
- * The names come from the MANIFEST, which is already where `authority` and
- * `reviewedBy` themselves are read from, so this adds no new trust and imports
- * no semantic module.
- *
- * ## Why it is a module of its own, and cached the way it is
- *
- * `registerPolicy` asks this for every policy that declares an authority — forty
- * times per hook event — and the honest answer costs a digest verification per
- * installed pack. So it is cached, and the cache is dropped by `clearPolicies()`:
- * one read per registration pass, and the answer's lifetime is exactly the
- * registry's. That is the right coupling rather than a convenient one — this set
- * describes the policies sitting in the registry, and the handler rebuilds both
- * together, so they cannot come to describe different machines.
- *
- * It lives beside `policy-registry.ts` rather than inside `pack-manifest.ts`
- * because the registry may not depend on the whole manifest reader: several
- * tests isolate themselves from the running machine's real packs by mocking
- * `pack-manifest` down to `readInstalledPacks` and `hasInstalledPacks`, and a
- * registration path reaching for a third export of that module breaks them all
- * — loudly here, but it is the shape of a change that would later break them
- * silently.
- */
-import { readInstalledPacks } from "./pack-manifest";
-import { SEMANTIC_REVIEWER_NAMES } from "./policy-authority";
-
-let cached: ReadonlySet<string> | null = null;
-
-/**
- * The installed packs' semantic policy names when any pack declares some, and
- * this build's compiled-in set otherwise.
- *
- * Never throws: an unreadable manifest declares nothing, and the builtin set
- * stands. That is the same fail-open posture every other reader of the pack
- * manifest takes, and here it also fails in the safe direction — a pack's
- * `reviewedBy` will not match a builtin name, so its policies stay `hard`
- * rather than being cleared by a question nobody could read.
- */
-export function effectiveReviewerNames(): ReadonlySet<string> {
-  if (cached) return cached;
-  let names: ReadonlySet<string> = SEMANTIC_REVIEWER_NAMES;
-  try {
-    const declared = readInstalledPacks().packs.flatMap((p) => (p.semantic ?? []).map((s) => s.name));
-    // Only when a pack actually declared some. A machine whose packs carry only
-    // the regex floor still runs the compiled-in semantic set, so its builtin
-    // reviewer names are the live ones.
-    if (declared.length > 0) names = new Set(declared);
-  } catch {
-    // See above: silence here is the builtin set, not an empty one.
-  }
-  cached = names;
-  return names;
-}
-
-/**
- * Drop the cached answer. Called by `clearPolicies()`, which every evaluation
- * runs before it registers anything — so a pack installed under a long-lived
- * warm worker is picked up on the next event rather than at the next restart.
- */
-export function forgetEffectiveReviewerNames(): void {
-  cached = null;
-}