failproofai 1.0.2-beta.4 → 1.0.2-beta.6

package/src/hooks/configure-wizard.ts

@@ -30,6 +30,8 @@ import { existsSync, mkdirSync, writeFileSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, resolve, sep } from "node:path";
 
+import { CORE_SOURCE } from "./pack-store";
+
 import {
   selectOne,
   promptText,
@@ -109,6 +111,31 @@ export interface WizardIO {
   stdout?: TTYOut;
 }
 
+/**
+ * Answers supplied up front, so the run needs nobody at the keyboard.
+ *
+ * This is the whole of headless setup, and it is small for a reason nobody
+ * planned: the wizard stopped DECIDING most of what it used to. Scope, agents,
+ * policies and the custom-policy toggle are all hardcoded now (see the
+ * constants further down), so there is no decision surface left to expose —
+ * only the three questions that remain, and each has one sensible unattended
+ * answer.
+ *
+ * None of this skips sudo. Installing a system service needs root and nothing
+ * here changes that: elevation goes through `sudo -n`, which never prompts, and
+ * a machine that cannot elevate is told exactly what to run as root.
+ */
+export interface WizardAnswers {
+  /** Cloud API key. Its presence IS the request to connect. */
+  token?: string;
+  /** Where to connect. Defaults to the same URL the wizard infers. */
+  url?: string;
+  machineId?: string;
+  machineLabel?: string;
+  /** Record decisions only, no session transcripts. */
+  noTranscripts?: boolean;
+}
+
 /**
  * Why a wizard run ended without applying. Distinguished so the caller can
  * pick an exit code — a user who pressed Esc did nothing wrong (exit 0), a
@@ -120,8 +147,9 @@ export type WizardAbort =
   | "needs_root"
   | "daemon_failed"
   | "unsupported_platform"
-  | "not_a_tty"
-  | "running_as_sudo";
+  | "running_as_sudo"
+  /** A cloud key was supplied and the server refused it. Unattended only. */
+  | "cloud_unverified";
 
 export interface WizardResult {
   applied: boolean;
@@ -695,19 +723,27 @@ export async function maybeFirstRunConfigure(
 
 // ── The wizard ───────────────────────────────────────────────────────────────
 
-export async function runConfigureWizard(io: WizardIO = {}): Promise<WizardResult> {
+export async function runConfigureWizard(
+  io: WizardIO = {},
+  answers: WizardAnswers = {},
+): Promise<WizardResult> {
   const stdin: TTYIn = io.stdin ?? process.stdin;
   const stdout: TTYOut = io.stdout ?? process.stdout;
   const cwd = process.cwd();
+  // No terminal means no questions — not a refusal.
+  //
+  // `failproofai config` IS the authorisation: somebody typed the command whose
+  // entire job is to configure this machine. Requiring a flag on top of that to
+  // permit what the command already means is asking the same question twice,
+  // and this used to refuse outright — so a CI job, a container or an agent
+  // could not set a machine up at all, which is the gap this closes.
+  //
+  // Safe to do here because the IMPLICIT path is guarded separately:
+  // `maybeFirstRunConfigure` has its own TTY check and returns before ever
+  // reaching this function, so setup never runs off the back of some other
+  // command on a headless box.
+  const unattended = !stdin.isTTY || !stdout.isTTY;
 
-  if (!stdin.isTTY || !stdout.isTTY) {
-    stdout.write(
-      "failproofai config needs an interactive terminal.\n" +
-        "Use the flag form instead, e.g.:\n" +
-        "  failproofai policies --install --scope user --cli claude\n",
-    );
-    return { applied: false };
-  }
 
   // Running the wizard itself under sudo configures the WRONG ACCOUNT, and
   // does it silently: homedir() becomes /root, so the hooks land in root's
@@ -724,7 +760,10 @@ export async function runConfigureWizard(io: WizardIO = {}): Promise<WizardResul
         "The one step that needs root (installing the service) asks for your password\n" +
         "on its own.\n",
     );
-    return { applied: false };
+    // Same reason as above: this configured nothing, and it is not a
+    // cancellation. `running_as_sudo` has been in `WizardAbort` since it was
+    // written and was never once assigned.
+    return { applied: false, abort: "running_as_sudo" };
   }
 
   // Fire-and-forget: never block the wizard's first paint on telemetry.
@@ -847,7 +886,13 @@ export async function runConfigureWizard(io: WizardIO = {}): Promise<WizardResul
         ? "failproofaid can't evaluate — every tool call is denied. Rebuilding needs sudo.\n\n"
         : "Installing failproofaid — needs sudo once.\n\n",
     );
-    if (!primeElevation()) {
+    // `primeElevation` runs `sudo -v`, which PROMPTS. An unattended run has
+    // nobody to type a password, so it goes straight to the `sudo -n` that
+    // `runPrivileged` uses anyway — exactly what `failproofai update` already
+    // does — and a machine that cannot elevate gets the commands below instead
+    // of a hung terminal. This is the same answer for both: sudo cannot be
+    // conjured away, only asked for at a moment somebody can answer.
+    if (!(unattended ? canElevate() : primeElevation())) {
       // Required means required: write nothing at all, so a machine that could
       // not be set up is left exactly as it was found rather than carrying
       // half a configuration. The commands are printed so an admin can do the
@@ -866,7 +911,7 @@ export async function runConfigureWizard(io: WizardIO = {}): Promise<WizardResul
       "failproofaid is running, but from a service definition written by an older\n" +
         "version — it cannot start a scheduled audit. Refreshing it needs root once.\n\n",
     );
-    if (!primeElevation()) {
+    if (!(unattended ? canElevate() : primeElevation())) {
       // NOT an abort, unlike the install branch above. There is a working
       // daemon here and hooks are enforcing; only the scheduled audit is out
       // of reach. Stopping setup over that would make an upgrade the thing
@@ -914,7 +959,7 @@ export async function runConfigureWizard(io: WizardIO = {}): Promise<WizardResul
   //
   // Setup no longer asks which policies to enable, and that is deliberate.
   // failproofai ships no policies of its own any more: they arrive as packs —
-  // from inside this package (`pack add core`) or from anyone's GitHub release.
+  // from inside this package (`policies add FailproofAI/policies`) or from anyone's GitHub release.
   // A wizard that pre-ticks OUR list makes a product decision on behalf of
   // somebody who has not seen the list yet, and not everyone wants the set we
   // would have chosen. So setup wires the hooks, and choosing what they
@@ -971,7 +1016,13 @@ export async function runConfigureWizard(io: WizardIO = {}): Promise<WizardResul
   let connect: { url: string; token: string; machineId: string; machineLabel: string } | null = null;
 
   {
-    const choice = await selectOne<"key" | "local">({
+    // Supplying a key IS asking to connect — there is no other reason to pass
+    // one — so an unattended run with a token skips straight past the question,
+    // and one without a token stays local, which is the same "Not now" branch a
+    // person picks. Neither needs a separate flag to say so.
+    const choice = unattended
+      ? (answers.token ? "key" : "local")
+      : await selectOne<"key" | "local">({
       message: "Connect this machine to FailproofAI Cloud?",
       // The hint says what you GET; the body says what LEAVES.
       //
@@ -1054,7 +1105,16 @@ export async function runConfigureWizard(io: WizardIO = {}): Promise<WizardResul
       let machineId = resolveMachineId();
       let machineLabel = existing?.machineLabel ?? resolveMachineLabel();
 
-      if (existing) {
+      if (existing && unattended && !answers.url) {
+        // Already enrolled, and this run did not name a different place to
+        // enrol. Reusing is what the person picks here too, and re-verifying a
+        // working credential is the one thing an unattended re-run must not
+        // turn into a failure.
+        url = existing.url;
+        token = answers.token ?? existing.token;
+        machineId = answers.machineId ?? existing.machineId;
+        machineLabel = answers.machineLabel ?? existing.machineLabel ?? machineLabel;
+      } else if (existing && !unattended) {
         const reuse = await selectOne<"reuse" | "other">({
           message: `Use this machine's existing connection to ${existing.url}?`,
           choices: [
@@ -1126,6 +1186,12 @@ export async function runConfigureWizard(io: WizardIO = {}): Promise<WizardResul
         }
       }
 
+      if (token === null && unattended) {
+        // Supplied on the command line, so nothing is asked and nothing is
+        // echoed. Reaching here without one cannot happen — an unattended run
+        // only takes the "key" branch BECAUSE a token was given.
+        token = answers.token ?? null;
+      }
       if (token === null) {
         token = await promptText({
           // The destination is in the question now that it is no longer a
@@ -1149,6 +1215,14 @@ export async function runConfigureWizard(io: WizardIO = {}): Promise<WizardResul
       // persisted here.
       stdout.write("\nChecking the key… ");
       const probe = await validateIngestKey({ url: ingestUrlFor(url), key: token });
+      if (!probe.ok && unattended) {
+        // A key that does not work is a FAILED setup, not a prompt. The
+        // interactive path offers "save it anyway" because a person can weigh
+        // an outage against their own impatience; a script cannot, and one that
+        // exited 0 here would leave a fleet believing it was reporting.
+        stdout.write(`\nThat key did not work: ${probe.reason}\n`);
+        return { applied: false, abort: "cloud_unverified" };
+      }
       if (!probe.ok) {
         stdout.write(`\nThat did not work: ${probe.reason}\n`);
         const retry = await selectOne<"skip" | "anyway">({
@@ -1173,7 +1247,15 @@ export async function runConfigureWizard(io: WizardIO = {}): Promise<WizardResul
     }
   }
   // 5 — Review & apply
-  const decision = await selectOne<"apply" | "cancel">({
+  //
+  // The last question, and the only one a headless run skips outright rather
+  // than answering from a flag. There is nothing to confirm when nobody is
+  // watching, and the command itself was the confirmation.
+  //
+  // NOT the same call as `uninstall`, which does require --yes: that one
+  // REMOVES things, so silence there would destroy on a signal as weak as a
+  // missing terminal. This one does exactly what its name says.
+  const decision = unattended ? "apply" : await selectOne<"apply" | "cancel">({
     message: "Ready to apply?",
     body: reviewLines({
       target,
@@ -1463,6 +1545,18 @@ export async function runConfigureWizard(io: WizardIO = {}): Promise<WizardResul
     { ok: true },
     stdout,
   );
+  // Setup wires the hooks and deliberately chooses NO policies, so a machine
+  // that has just finished it enforces almost nothing — and the summary line
+  // says "0 policies" without saying what to do about it. Anyone else's pack is
+  // typed the same way, which is the point: ours is named in full rather than
+  // by a short name only we could use.
+  if (policies.length === 0) {
+    stdout.write(
+      `\n  Nothing is enforcing yet. Take ours, or anyone's:\n` +
+        `    failproofai policies add ${CORE_SOURCE}\n` +
+        `    failproofai policies show <owner>/<repo>   (look first)\n\n`,
+    );
+  }
   return {
     applied: true,
     target,

package/src/hooks/fp-reset.ts

@@ -973,7 +973,7 @@ export function resetHome(from: number, to: number = LAYOUT_VERSION): ResetOutco
   //
   // Nothing needs carrying either: `enabledPolicies` is left exactly where it
   // is, and the no-pack fallback reads it, so a machine mid-upgrade keeps
-  // enforcing precisely what it enforced before. `failproofai policies add core`
+  // enforcing precisely what it enforced before. `failproofai policies add FailproofAI/policies`
   // turns those names into a real pack, carrying the same selection into it.
   // The step's OWN target, not LAYOUT_VERSION.
   //

package/src/hooks/handler.ts

@@ -323,7 +323,7 @@ export async function evaluateHookEvent(
       if (legacyNames.length > 0) {
         hookLogWarn(
           `enforcing ${legacyNames.length} policies from this build because no pack is installed — ` +
-            `run \`failproofai policies add core\` to move them into a real pack`,
+            `run \`failproofai policies add FailproofAI/policies\` to move them into a real pack`,
         );
       }
       // What actually registered, for the pack-duplicate check below. A paused
@@ -786,6 +786,18 @@ export async function handleHookEvent(eventType: string, cli: IntegrationType =
       error_type: "oversized",
     });
   }
+  if (stdinRead.timedOut) {
+    // Reported distinctly from a read error because the remedy is different and
+    // the cause is upstream: the agent spawned the hook and did not close its
+    // stdin. Before this was bounded it was not reported at all — the process
+    // simply never returned, and the tool call it was gating never resolved.
+    hookLogWarn(`stdin never closed for ${eventType}; evaluated nothing`);
+    void trackHookEvent(getInstanceId(), "hook_stdin_error", {
+      event_type: eventType,
+      cli,
+      error_type: "timeout",
+    });
+  }
 
   const result = await evaluateHookEvent(eventType, cli, stdinRead.payload);
 

package/src/hooks/manager.ts

@@ -14,7 +14,7 @@ import { INTEGRATION_TYPES,
   type HookScope,
   type IntegrationType,
 } from "./types";
-import { claudeCode, getIntegration, settingsPathsFor } from "./integrations";
+import { claudeCode, getIntegration, settingsPathsFor, type Integration } from "./integrations";
 import { promptPolicySelection } from "./install-prompt";
 import { configuredCustomPolicyPaths, readMergedHooksConfig, readScopedHooksConfig, writeScopedHooksConfig, syncConventionPolicies, findProjectConfigDir } from "./hooks-config";
 import type { HooksConfig, ConventionPolicyRecord } from "./policy-types";
@@ -271,9 +271,44 @@ function deduplicateScopes(scopes: readonly HookScope[], cwd?: string): HookScop
  * rows of the listing already answer it.
  */
 export function hooksInstalledInSettings(scope: HookScope, cwd?: string): boolean {
-  return INTEGRATION_TYPES.some((id) => {
+  return integrationsInstalledAt(scope, cwd).length > 0;
+}
+
+/**
+ * Which integrations are wired at EXACTLY this scope — the honest form of the
+ * question above, and the one the multi-scope warning needs.
+ *
+ * Two ways an integration answers yes for a scope it is not actually installed
+ * at, both of which made `failproofai policies` warn about "hooks in multiple
+ * scopes" on a machine whose hooks are in exactly one file:
+ *
+ *  - It does not SUPPORT the scope. Hermes and OpenClaw are user-scope only
+ *    (`HERMES_HOOK_SCOPES = ["user"]`) and their `getSettingsPath` ignores the
+ *    scope argument entirely, so they hand back the user file — and report it
+ *    installed — for `project` and `local` alike. `scopes` already declares
+ *    this; nothing was reading it.
+ *  - Its project path RESOLVES to its user path. Run this from `$HOME` and
+ *    `<cwd>/.claude/settings.json` is `~/.claude/settings.json`: one file,
+ *    counted as two scopes. Cheap to detect and impossible to get right by
+ *    asking each integration separately.
+ */
+export function integrationsInstalledAt(scope: HookScope, cwd?: string): IntegrationType[] {
+  return INTEGRATION_TYPES.filter((id) => {
     try {
-      return getIntegration(id).hooksInstalledInSettings(scope, cwd);
+      const integration = getIntegration(id);
+      if (!integration.scopes.includes(scope)) return false;
+      if (!integration.hooksInstalledInSettings(scope, cwd)) return false;
+      // A narrower scope that lands on the same file as a wider one is that
+      // wider one, seen twice. Attribute it to the widest scope that resolves
+      // there so exactly one of them counts.
+      const here = integration.getSettingsPath(scope, cwd);
+      return !HOOK_SCOPES.some(
+        (other) =>
+          other !== scope &&
+          HOOK_SCOPES.indexOf(other) < HOOK_SCOPES.indexOf(scope) &&
+          integration.scopes.includes(other) &&
+          safeSettingsPath(integration, other, cwd) === here,
+      );
     } catch {
       // An integration whose settings file is unreadable is not evidence that
       // nothing is installed — keep asking the rest.
@@ -282,6 +317,18 @@ export function hooksInstalledInSettings(scope: HookScope, cwd?: string): boolea
   });
 }
 
+function safeSettingsPath(
+  integration: Integration,
+  scope: HookScope,
+  cwd?: string,
+): string | null {
+  try {
+    return integration.getSettingsPath(scope, cwd);
+  } catch {
+    return null;
+  }
+}
+
 export interface InstallHooksOptions {
   /** Replace the enabled set at this scope instead of unioning (default: additive). */
   replace?: boolean;
@@ -531,7 +578,7 @@ async function installHooksImpl(
       } catch (err) {
         console.log(
           `\nWarning: could not fetch the policy pack (${err instanceof Error ? err.message : String(err)}).\n` +
-            `Run \`failproofai policies add core\` once you are online.`,
+            `Run \`failproofai policies add FailproofAI/policies\` once you are online.`,
         );
       }
     } else {
@@ -944,6 +991,24 @@ export async function listHooks(cwd?: string): Promise<void> {
   // a reader scrolling back from their prompt actually sees.
   const footer: Array<string[] | null> = [note(`Config: ${globalPolicyConfigFile()}`, opts)];
 
+  // A machine with hooks wired and no policies to run is the normal state right
+  // after setup — setup installs the hooks and deliberately chooses nothing —
+  // and this listing said NOTHING about how to leave it. A reader who had just
+  // finished `failproofai config` saw a header, a config path, and no next
+  // step. Ours is named in full, the same way anyone else's pack is typed,
+  // because it IS one.
+  if (packCount === 0) {
+    footer.unshift(
+      nextStep(
+        `failproofai policies add ${CORE_SOURCE}`,
+        "Nothing is enforcing yet. Take ours, or anyone's:",
+        opts,
+      ),
+      note("Someone else's:  failproofai policies add <owner>/<repo>", opts),
+      note("Look first:      failproofai policies show <owner>/<repo>", opts),
+    );
+  }
+
   if (installedScopes.length > 1) {
     footer.push(
       warning(

package/src/hooks/onboarding-attempt.ts

@@ -157,10 +157,11 @@ export function blockerCleared(attempt: OnboardingAttempt, probe: RetryProbe): b
       // command would just repeat the hard-fail. Only a new release is a reason
       // to ask again (it might add support for this platform).
       return probe.cliVersion !== attempt.cliVersion;
-    case "not_a_tty":
     case "running_as_sudo":
-      // Both are properties of the invocation, not of the machine, so the next
-      // one may well be fine.
+      // A property of the invocation, not of the machine, so the next one may
+      // well be fine. (`not_a_tty` used to sit here too. It is gone because
+      // there is no such refusal any more: a run with no terminal has no
+      // questions to ask, so it applies rather than declining.)
       return true;
     default:
       return true;
@@ -174,7 +175,6 @@ export function attemptHintLines(attempt: OnboardingAttempt): string[] {
     daemon_failed: "the failproofaid service could not be started",
     cancelled: "it was cancelled",
     unsupported_platform: "failproofaid does not run on this platform",
-    not_a_tty: "there was no terminal to ask in",
     running_as_sudo: "it was run under sudo",
   };
   const detail = why[attempt.reason] ?? "it did not finish";