failproofai 1.0.0-beta.2 → 1.0.0-beta.3

package/.next/standalone/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "3"
 members = ["crates/*"]
 
 [workspace.package]
-version = "1.0.0-beta.2"
+version = "1.0.0-beta.3"
 edition = "2024"
 license-file = "LICENSE"
 repository = "https://github.com/FailproofAI/failproofai"

package/.next/standalone/app/actions/get-active-pauses.ts

@@ -0,0 +1,16 @@
+"use server";
+
+import { listActivePauses } from "@/src/hooks/session-pause";
+import type { ActivePause } from "@/src/hooks/session-pause";
+
+/**
+ * Sessions whose enforcement is paused right now.
+ *
+ * Read live rather than derived from activity rows: a pause set seconds ago has
+ * produced no rows yet, and that is exactly the moment someone needs to be told
+ * the machine is unguarded. Expiry is applied at read time, so an expired pause
+ * simply stops appearing.
+ */
+export async function getActivePausesAction(): Promise<ActivePause[]> {
+  return listActivePauses();
+}

package/.next/standalone/app/components/pause-notices.tsx

@@ -0,0 +1,111 @@
+"use client";
+
+/**
+ * The dashboard's rendering of a paused machine.
+ *
+ * Split out of `hooks-client.tsx` because these are the pieces that keep the
+ * activity view honest: a row evaluated during a pause looks identical to one
+ * where every policy ran and allowed, and without saying so the log asserts a
+ * clean window over exactly the window that was not enforced.
+ */
+import React, { useEffect, useState } from "react";
+import { ShieldAlert, TriangleAlert } from "lucide-react";
+import type { ActivePause } from "@/src/hooks/session-pause";
+
+/** Compact "time left" for a future timestamp. */
+export function formatRemaining(ms: number): string {
+  if (ms <= 0) return "expiring now";
+  // Sub-minute is checked before rounding: Math.round(30s) is "1m", which tells
+  // someone they have more time than they do. On a countdown to enforcement
+  // coming back, never round up.
+  if (ms < 60_000) return "under a minute";
+  const minutes = Math.round(ms / 60_000);
+  if (minutes < 60) return `${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  const rest = minutes % 60;
+  return rest === 0 ? `${hours}h` : `${hours}h${rest}m`;
+}
+
+/**
+ * Live state, not history: enforcement is paused RIGHT NOW.
+ *
+ * The rows below cannot carry this on their own — a pause set seconds ago has
+ * produced none yet, and that is precisely when someone needs telling that the
+ * machine is unguarded. An absent banner has to mean "enforcing", so this is fed
+ * from live pause state rather than inferred from whatever is on screen.
+ */
+export function PausedBanner({ pauses, now: nowProp }: { pauses: ActivePause[]; now?: number }) {
+  const [tick, setTick] = useState(() => Date.now());
+  // Re-render on a timer so "22m left" does not sit frozen while the pause
+  // silently drains away.
+  useEffect(() => {
+    const id = setInterval(() => setTick(Date.now()), 30_000);
+    return () => clearInterval(id);
+  }, []);
+  const now = nowProp ?? tick;
+
+  // Filter again here rather than trusting the fetch: the list was accurate
+  // when it arrived, and a short pause can expire between polls.
+  const live = pauses.filter((p) => p.expiresAt > now);
+  if (live.length === 0) return null;
+  const soonest = live.reduce((a, b) => (a.expiresAt < b.expiresAt ? a : b));
+
+  return (
+    <div
+      role="status"
+      className="mb-4 flex items-start gap-2.5 rounded border border-amber-500/40 bg-amber-500/[0.07] px-3 py-2.5"
+    >
+      <ShieldAlert className="h-4 w-4 shrink-0 text-amber-500 mt-0.5" aria-hidden="true" />
+      <div className="text-xs leading-relaxed">
+        <p className="font-medium text-foreground">
+          Enforcement is paused for {live.length} session{live.length === 1 ? "" : "s"} —{" "}
+          {formatRemaining(soonest.expiresAt - now)} left
+          {live.length > 1 ? " on the next to expire" : ""}.
+        </p>
+        <p className="text-muted-foreground mt-0.5">
+          Builtin, custom and convention policies are suspended for{" "}
+          {live.length === 1 ? "that session" : "those sessions"}; cloud-managed policies keep
+          enforcing. It lifts on its own — or run{" "}
+          <span className="font-mono text-foreground">failproofai config --resume</span>.
+        </p>
+      </div>
+    </div>
+  );
+}
+
+/** Marks a row that was evaluated while enforcement was paused. */
+export function PausedPill() {
+  return (
+    <span
+      title="Enforcement was paused for this session — local policies did not run"
+      className="ml-1.5 inline-flex items-center rounded px-1.5 py-0.5 text-[0.6rem] font-medium uppercase tracking-wide border border-amber-500/40 bg-amber-500/10 text-amber-600 dark:text-amber-500"
+    >
+      paused
+    </span>
+  );
+}
+
+/** Why an `allow` on this row proves nothing. */
+export function PausedNote({
+  item,
+}: {
+  item: { pausedBy?: string; pauseExpiresAt?: number };
+}) {
+  if (!item.pausedBy) return null;
+  const lifted =
+    typeof item.pauseExpiresAt === "number"
+      ? new Date(item.pauseExpiresAt).toLocaleTimeString()
+      : null;
+  return (
+    <div className="sm:col-span-2 lg:col-span-3 mt-1 flex items-start gap-2 rounded border border-amber-500/30 bg-amber-500/5 px-2.5 py-2">
+      <TriangleAlert className="h-3.5 w-3.5 shrink-0 text-amber-500/80 mt-0.5" aria-hidden="true" />
+      <p className="text-[0.7rem] leading-relaxed text-muted-foreground">
+        <span className="font-medium text-foreground">Not enforced — paused.</span> Enforcement was
+        suspended for this session
+        {item.pausedBy === "cli" ? " from the CLI" : ` by ${item.pausedBy}`}
+        {lifted ? `, lifting at ${lifted}` : ""}. Builtin, custom and convention policies did not
+        run for this event; cloud-managed policies did.
+      </p>
+    </div>
+  );
+}

package/.next/standalone/app/policies/hooks-client.tsx

@@ -7,6 +7,9 @@ import { Check, ChevronDown, Code, Copy, Settings, Shield, ShieldAlert, ShieldCh
 import PaginationControls from "@/app/components/pagination-controls";
 import { getHookActivityAction, searchHookActivityAction } from "@/app/actions/get-hook-activity";
 import type { HookActivityPayload } from "@/app/actions/get-hook-activity";
+import { getActivePausesAction } from "@/app/actions/get-active-pauses";
+import type { ActivePause } from "@/src/hooks/session-pause";
+import { PausedBanner, PausedNote, PausedPill } from "@/app/components/pause-notices";
 import { getHooksConfigAction } from "@/app/actions/get-hooks-config";
 import type { HooksConfigPayload, PolicyInfo, CustomPolicyInfo } from "@/app/actions/get-hooks-config";
 import type { IntegrationType } from "@/src/hooks/types";
@@ -386,7 +389,27 @@ function DetailPanel({
             event detail
           </span>
           <div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 gap-x-8 gap-y-2">
+            <PausedNote item={item} />
             <EnforcementNote item={item} />
+            {item.policySource && (
+              <div>
+                <span className="text-muted-foreground">Decided by: </span>
+                <span className="font-mono text-foreground">
+                  {item.policySource === "cloud" && item.cloudPolicyId
+                    ? `cloud · ${item.cloudPolicyId} rev ${item.cloudRevision}`
+                    : item.policySource}
+                </span>
+              </div>
+            )}
+            {item.cloudGeneration !== undefined && (
+              <div>
+                {/* Present on every row of a managed machine, not just cloud
+                    decisions — it is what separates a rollout that changed no
+                    outcomes from one that never arrived. */}
+                <span className="text-muted-foreground">Cloud generation: </span>
+                <span className="font-mono text-foreground">{item.cloudGeneration}</span>
+              </div>
+            )}
             <div>
               <span className="text-muted-foreground">Session ID: </span>
               <span className="font-mono text-foreground">
@@ -443,6 +466,7 @@ function ActivityTab({
 
   const [page, setPage] = useState(() => paramToPage(url.get("page")));
   const [data, setData] = useState<HookActivityPayload | null>(null);
+  const [activePauses, setActivePauses] = useState<ActivePause[]>([]);
   const [expandedRow, setExpandedRow] = useState<number | null>(null);
 
   const [filterDecision, setFilterDecision] = useState<"" | "allow" | "deny" | "instruct">(() => {
@@ -456,10 +480,14 @@ function ActivityTab({
     const v = url.get("cli");
     return isKnownCli(v) ? v : "";
   });
+  const [filterSource, setFilterSource] = useState<"" | "builtin" | "custom" | "convention" | "cloud">(() => {
+    const v = url.get("source");
+    return v === "builtin" || v === "custom" || v === "convention" || v === "cloud" ? v : "";
+  });
   const debounceRef = useRef<ReturnType<typeof setTimeout> | null>(null);
   const filterTelemetryFirstRunRef = useRef(true);
-  const filtersRef = useRef({ filterDecision, filterEventType, filterPolicy, filterSessionId, filterCli });
-  filtersRef.current = { filterDecision, filterEventType, filterPolicy, filterSessionId, filterCli };
+  const filtersRef = useRef({ filterDecision, filterEventType, filterPolicy, filterSessionId, filterCli, filterSource });
+  filtersRef.current = { filterDecision, filterEventType, filterPolicy, filterSessionId, filterCli, filterSource };
 
   useEffect(() => {
     if (!mountedRef.current) {
@@ -472,17 +500,18 @@ function ActivityTab({
       policy: filterPolicy || undefined,
       session: filterSessionId || undefined,
       cli: filterCli || undefined,
+      source: filterSource || undefined,
       page: pageToParam(page),
     });
   // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [filterDecision, filterEventType, filterPolicy, filterSessionId, filterCli, page]);
+  }, [filterDecision, filterEventType, filterPolicy, filterSessionId, filterCli, filterSource, page]);
 
-  const hasActiveFilters = filterDecision !== "" || filterEventType !== "" || filterPolicy !== "" || filterSessionId !== "" || filterCli !== "";
+  const hasActiveFilters = filterDecision !== "" || filterEventType !== "" || filterPolicy !== "" || filterSessionId !== "" || filterCli !== "" || filterSource !== "";
 
   const fetchData = useCallback(async (p: number) => {
     try {
-      const { filterDecision: fd, filterEventType: fe, filterPolicy: fp, filterSessionId: fs, filterCli: fc } = filtersRef.current;
-      const active = fd !== "" || fe !== "" || fp !== "" || fs !== "" || fc !== "";
+      const { filterDecision: fd, filterEventType: fe, filterPolicy: fp, filterSessionId: fs, filterCli: fc, filterSource: fsrc } = filtersRef.current;
+      const active = fd !== "" || fe !== "" || fp !== "" || fs !== "" || fc !== "" || fsrc !== "";
       let result: HookActivityPayload;
       if (active) {
         result = await searchHookActivityAction(
@@ -492,6 +521,7 @@ function ActivityTab({
             policyName: fp || undefined,
             sessionId: fs || undefined,
             integration: fc || undefined,
+            source: fsrc || undefined,
           },
           p,
         );
@@ -511,6 +541,22 @@ function ActivityTab({
     return () => clearInterval(id);
   }, [page, fetchData, intervalSec]);
 
+  // Pause state is polled independently of the activity page: it is live
+  // machine state, not a property of whichever rows are on screen, and it must
+  // keep updating while the user sits on page 3 of history.
+  useEffect(() => {
+    let cancelled = false;
+    const load = () => {
+      getActivePausesAction()
+        .then((p) => { if (!cancelled) setActivePauses(p); })
+        .catch(() => { /* non-critical: the banner simply stays hidden */ });
+    };
+    load();
+    const ms = intervalSec > 0 ? intervalSec * 1000 : 5000;
+    const id = setInterval(load, ms);
+    return () => { cancelled = true; clearInterval(id); };
+  }, [intervalSec]);
+
   useEffect(() => {
     if (debounceRef.current) clearTimeout(debounceRef.current);
     debounceRef.current = setTimeout(() => {
@@ -565,6 +611,10 @@ function ActivityTab({
 
   return (
     <>
+      {/* Above the stats, deliberately: a paused machine is the most important
+          thing on this screen, and the numbers below it are being produced with
+          local enforcement switched off. */}
+      <PausedBanner pauses={activePauses} />
       {data?.stats && data.stats.totalEvents > 0 && (
         <div style={{ marginBottom: 18 }}>
           <StatsBar stats={data.stats} />
@@ -593,6 +643,29 @@ function ActivityTab({
               <option value="PermissionRequest">PermissionRequest</option>
             </select>
           </div>
+          <div className="filter-group">
+            {/* "What did my organization's policies decide here?" is the
+                question cloud rollout reporting rests on, and it is
+                unanswerable while the source is only a prefix on a name. */}
+            <span className="filter-label">source</span>
+            <select
+              value={filterSource}
+              onChange={(e) => {
+                const v = e.target.value;
+                setFilterSource(
+                  v === "builtin" || v === "custom" || v === "convention" || v === "cloud" ? v : "",
+                );
+              }}
+              className="filter-input"
+              aria-label="Filter by policy source"
+            >
+              <option value="">all sources</option>
+              <option value="builtin">builtin</option>
+              <option value="custom">custom</option>
+              <option value="convention">convention</option>
+              <option value="cloud">cloud</option>
+            </select>
+          </div>
           <div className="filter-group">
             <span className="filter-label">cli</span>
             <select
@@ -642,6 +715,7 @@ function ActivityTab({
                 setFilterCli("");
                 setFilterPolicy("");
                 setFilterSessionId("");
+                setFilterSource("");
               }}
               aria-label="Clear all filters"
             >
@@ -744,6 +818,7 @@ function ActivityTab({
                         </td>
                         <td className="px-3 py-2">
                           <DecisionBadge decision={item.decision} />
+                          {item.pausedBy && <PausedPill />}
                         </td>
                         <td className="px-3 py-2">
                           <EventTypeBadge eventType={item.eventType} />

package/.next/standalone/crates/CLOUD_POLICIES.md

@@ -0,0 +1,136 @@
+# Cloud-managed policy generations
+
+This is the contract between the Failproof Cloud HTTP transport and the
+`failproofaid` policy worker. Polling and integrity maintenance run outside the
+hook path; hooks evaluate only the last verified local generation.
+
+## Layout
+
+```text
+~/.failproofai/policies/cloud-managed/
+├── desired-state.json
+├── active.json
+├── artifacts/
+│   └── <sha256>.mjs
+└── generations/
+    └── <generation>/
+        ├── manifest.json
+        └── <policy-id>.mjs
+```
+
+- `desired-state.json` is the last complete desired-state snapshot received
+  from cloud. A later slice must authenticate it with a publisher signature;
+  SHA-256 alone proves byte identity, not publisher identity.
+- `artifacts/` is a content-addressed cache.
+- `generations/` contains complete materialized policy sets. New generations
+  are built without modifying the active one.
+- `active.json` is an atomically replaced pointer to one complete generation.
+  It is derived state and is reconstructed when it is deleted, malformed, or
+  disagrees with `desired-state.json`.
+
+## Desired-state schema
+
+```json
+{
+  "schemaVersion": 1,
+  "generation": 184,
+  "policies": [
+    {
+      "id": "block-secret-exfiltration",
+      "revision": 7,
+      "sha256": "<64 lowercase hex characters>",
+      "artifactUrl": "https://..."
+    }
+  ]
+}
+```
+
+The artifact URL is opaque to the store. A cloud client supplies downloaded
+bytes through `ArtifactFetcher`; the reconciler trusts none of those bytes
+until their SHA-256 matches the desired state.
+
+## Cloud transport
+
+Enrol with the CLI:
+
+```bash
+failproofai config --connect https://be.failproof.ai \
+  --token <org-scoped policies:pull key> \
+  --machine-id prod-runner-01     # defaults to this host's name
+```
+
+That verifies the credentials against the server before storing anything, then
+writes `~/.failproofai/cloud.json` (mode 0600). `--disconnect` removes it,
+`--status` reports the connection with the token masked.
+
+**The credential must not go in the service unit.** `daemon-service.ts` installs
+`/etc/systemd/system/failproofaid@<user>.service` at mode 0644 — root-owned and
+world-readable — and the launchd plist likewise. An
+`Environment="FAILPROOFAI_CLOUD_TOKEN=…"` line there hands an organization-scoped
+key to every local user, and `systemctl show` prints it back with no privilege
+at all. Keeping it in a file also means enrolment, rotation and disconnect need
+no root, and an already-installed daemon can be connected without reinstalling.
+
+The daemon re-resolves enrolment on **every poll**, not at startup, so all three
+take effect within one interval with nothing to restart — which matters because
+restarting a system unit needs root, the very thing this avoids.
+
+Environment variables still take precedence over the file, for CI, containers
+and tests:
+
+```text
+FAILPROOFAI_CLOUD_URL=https://be.failproof.ai
+FAILPROOFAI_CLOUD_TOKEN=<org-scoped policies:pull key>
+FAILPROOFAI_MACHINE_ID=<deployment machine id>
+FAILPROOFAI_CLOUD_CREDENTIALS=<path>   # overrides ~/.failproofai/cloud.json
+```
+
+`FAILPROOFAI_CLOUD_POLICY_POLL_MS` controls the interval (30 seconds by
+default, clamped to at least 100 ms). The client sends Bearer authentication
+to both desired-state and artifact endpoints. Relative artifact locators are
+resolved against the configured base URL; cross-origin locators are rejected
+before the token is sent.
+
+An HTTP failure, invalid desired-state response, bad digest, or incomplete
+generation leaves the previous generation active.
+
+## Activation transaction
+
+1. Validate schema, policy IDs, unique IDs, digests, and monotonic generation.
+2. Reuse a verified cache/generation copy or fetch missing bytes.
+3. Verify every artifact digest.
+4. Materialize the complete generation and `fsync` its files/directories.
+5. Persist `desired-state.json`.
+6. Atomically replace `active.json`.
+
+Any failure before step 6 leaves the previous generation active. The worker
+loads only paths named by `active.json` and independently verifies every digest
+immediately before importing JavaScript.
+
+## Integrity maintenance
+
+`failproofaid` runs a maintenance thread outside the hook path. It hashes the
+active generation periodically (30 seconds by default) and repairs either a
+modified generation copy or a modified content-addressed artifact from the
+other verified copy. If both are gone, it retains the active manifest and
+reports that a cloud re-fetch is required.
+
+`FAILPROOFAI_CLOUD_POLICY_DIR` overrides the root for tests and development.
+When cloud polling is disabled, `FAILPROOFAI_CLOUD_POLICY_RECONCILE_MS`
+overrides the standalone integrity interval, clamped to at least 100 ms. With
+cloud polling enabled, integrity repair runs on each poll.
+
+## Current security boundary
+
+PR #632 runs the daemon as the same OS user as the governed agent. This layer
+provides deterministic deployment, drift detection, and self-healing, but it
+does not make policies tamper-proof against that user. The user can stop the
+service or delete both verified copies. Publisher signatures, deployment
+acknowledgement, and a stronger service identity are separate follow-up layers.
+The current machine credential is an org-scoped Bearer key transported over
+HTTPS.
+
+Downloaded JavaScript executes in the existing TypeScript policy worker with
+the user's authority. Cloud authorization must therefore treat assigning an
+arbitrary JavaScript policy as remote code execution until a sandboxed policy
+runtime exists.

package/.next/standalone/crates/failproofaid/Cargo.toml

@@ -13,6 +13,13 @@ path = "src/main.rs"
 
 [dependencies]
 fpai-ipc = { path = "../fpai-ipc" }
+fpai-collect = { path = "../fpai-collect" }
+# Without a subscriber every `tracing::` call in fpai-collect is silently
+# discarded — including the uploader's "the server stored NONE of its events".
+tracing = "0.1"
+tracing-subscriber = { version = "0.3", default-features = false, features = ["std", "fmt", "env-filter"] }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 libc = "0.2"
+sha2 = "0.10"
+reqwest = { version = "0.12", default-features = false, features = ["blocking", "json", "rustls-tls"] }