@fidacy/mcp 0.5.1 → 0.6.0

package/dist/lib.js

@@ -643,7 +643,7 @@ function resolveMandateRules(cfg) {
 }
 
 // src/telemetry.ts
-var CLIENT_VERSION = true ? "0.5.1" : "dev";
+var CLIENT_VERSION = true ? "0.6.0" : "dev";
 function bandOf(amount) {
   if (typeof amount !== "number" || !Number.isFinite(amount) || amount <= 0) return void 0;
   if (amount < 10) return "lt10";
@@ -831,7 +831,7 @@ function requestUpgrade() {
 }
 
 // src/provision.ts
-var CLIENT_VERSION2 = true ? "0.5.1" : "dev";
+var CLIENT_VERSION2 = true ? "0.6.0" : "dev";
 function provisionEnabled() {
   const v = (process.env.FIDACY_DISABLE_PROVISION ?? "").trim().toLowerCase();
   return !(v === "1" || v === "true" || v === "yes");
@@ -994,7 +994,7 @@ function activationBootLine() {
 }
 
 // src/register.ts
-var CLIENT_VERSION3 = true ? "0.5.1" : "dev";
+var CLIENT_VERSION3 = true ? "0.6.0" : "dev";
 function endpoint3() {
   const base = (process.env.FIDACY_ENGINE_URL ?? "https://api.fidacy.com").replace(/\/$/, "");
   return `${base}/v1/register`;

package/dist/nudges.d.ts

@@ -11,7 +11,7 @@
  *
  * All writes are best-effort: a read-only disk silences nudges, never the firewall.
  */
-export type NudgeKey = "first_deny" | "first_allow" | "bec_catch" | "milestone_10" | "week_1" | "proof_teaser" | "hosted_wall";
+export type NudgeKey = "first_deny" | "first_allow" | "bec_catch" | "milestone_10" | "week_1" | "proof_teaser" | "hosted_wall" | "setup_email_ask";
 /**
  * The claim URL for THIS install: fidacy.com/claim?ref=<anon_id> shows the
  * operator what the firewall already blocked here and starts a free account

package/dist/postinstall.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/postinstall.js

@@ -0,0 +1,255 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/config.ts
+import { randomUUID } from "node:crypto";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync
+} from "node:fs";
+function configDir() {
+  return process.env.FIDACY_CONFIG_DIR ?? join(homedir(), ".fidacy");
+}
+function configPath() {
+  return join(configDir(), "config.json");
+}
+function readConfig() {
+  const p = configPath();
+  if (!existsSync(p)) return null;
+  try {
+    const raw = JSON.parse(readFileSync(p, "utf8"));
+    if (!raw || typeof raw.anon_id !== "string") return null;
+    return {
+      anon_id: raw.anon_id,
+      tier: raw.tier === "paid" ? "paid" : "free",
+      api_key: typeof raw.api_key === "string" ? raw.api_key : null,
+      mandate: raw.mandate,
+      // Install-state passthrough: dropping these on a read→write cycle would
+      // reset every once-per-install nudge into an every-time nag.
+      created_at: typeof raw.created_at === "string" ? raw.created_at : void 0,
+      nudges: raw.nudges && typeof raw.nudges === "object" ? raw.nudges : void 0,
+      decisions_count: typeof raw.decisions_count === "number" ? raw.decisions_count : void 0,
+      hosted_lapsed_at: typeof raw.hosted_lapsed_at === "string" ? raw.hosted_lapsed_at : void 0,
+      operator_email: typeof raw.operator_email === "string" ? raw.operator_email : void 0,
+      registered_email: typeof raw.registered_email === "string" ? raw.registered_email : void 0
+    };
+  } catch {
+    return null;
+  }
+}
+function writeConfig(cfg) {
+  const dir = configDir();
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  writeFileSync(configPath(), JSON.stringify(cfg, null, 2), { mode: 384 });
+}
+function ensureState() {
+  const existing = readConfig();
+  if (existing) return { config: existing, firstRun: false };
+  const config = {
+    anon_id: randomUUID(),
+    tier: "free",
+    api_key: null,
+    mandate: { payees: [], categories: ["*"], currency: "USD", perTxMax: 2500, maxTotal: 1e4 },
+    created_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  try {
+    writeConfig(config);
+  } catch {
+  }
+  return { config, firstRun: true };
+}
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+  }
+});
+
+// src/register.ts
+function endpoint() {
+  const base = (process.env.FIDACY_ENGINE_URL ?? "https://api.fidacy.com").replace(/\/$/, "");
+  return `${base}/v1/register`;
+}
+function looksLikeEmail(s) {
+  return /^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(s);
+}
+function operatorEmail(override) {
+  const raw = (override ?? process.env.FIDACY_OPERATOR_EMAIL ?? readConfig()?.operator_email ?? "").trim();
+  return raw && looksLikeEmail(raw) ? raw : null;
+}
+async function registerEmail(email, shell = "mcp") {
+  const cfg = readConfig();
+  if (!cfg) return "skipped";
+  const clean = email.trim();
+  if (!looksLikeEmail(clean)) return "skipped";
+  if (cfg.registered_email && cfg.registered_email.toLowerCase() === clean.toLowerCase()) return "skipped";
+  try {
+    const res = await fetch(endpoint(), {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ anon_id: cfg.anon_id, email: clean, client_version: CLIENT_VERSION, shell })
+    });
+    if (res.status === 429) return "rate_limited";
+    if (!res.ok) return "failed";
+    const fresh = readConfig() ?? cfg;
+    writeConfig({ ...fresh, operator_email: clean, registered_email: clean });
+    return "registered";
+  } catch {
+    return "failed";
+  }
+}
+function rememberOperatorEmail(email) {
+  const cfg = readConfig();
+  if (!cfg) return;
+  const clean = email.trim();
+  if (!looksLikeEmail(clean)) return;
+  try {
+    writeConfig({ ...cfg, operator_email: clean });
+  } catch {
+  }
+}
+function needsOperatorEmail() {
+  const cfg = readConfig();
+  if (!cfg) return false;
+  return !cfg.registered_email && !operatorEmail();
+}
+var CLIENT_VERSION;
+var init_register = __esm({
+  "src/register.ts"() {
+    "use strict";
+    init_config();
+    CLIENT_VERSION = true ? "0.6.0" : "dev";
+  }
+});
+
+// src/nudges.ts
+var init_nudges = __esm({
+  "src/nudges.ts"() {
+    "use strict";
+    init_config();
+  }
+});
+
+// src/telemetry.ts
+var init_telemetry = __esm({
+  "src/telemetry.ts"() {
+    "use strict";
+    init_config();
+  }
+});
+
+// src/activation.ts
+var init_activation = __esm({
+  "src/activation.ts"() {
+    "use strict";
+    init_config();
+    init_nudges();
+    init_telemetry();
+  }
+});
+
+// src/protection.ts
+var BRAND;
+var init_protection = __esm({
+  "src/protection.ts"() {
+    "use strict";
+    init_config();
+    init_activation();
+    init_nudges();
+    BRAND = "Fidacy AI Agent Firewall";
+  }
+});
+
+// src/setup.ts
+var setup_exports = {};
+__export(setup_exports, {
+  isInteractive: () => isInteractive,
+  registeredEmail: () => registeredEmail,
+  runSetup: () => runSetup
+});
+import { createInterface } from "node:readline/promises";
+function isInteractive() {
+  if (process.env.CI || process.env.FIDACY_NONINTERACTIVE) return false;
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+function looksLikeEmail2(s) {
+  return /^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(s);
+}
+async function runSetup(opts = {}) {
+  if (!opts.force && !isInteractive()) return "skipped_noninteractive";
+  ensureState();
+  if (!needsOperatorEmail() && !opts.force) return "already";
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    process.stdout.write(`
+  ${BRAND}
+`);
+    process.stdout.write(
+      "  Your email keeps this agent's protection history and lets it move into a free account.\n  Optional \u2014 press Enter to skip. You are never emailed without reason, and can remove it any time.\n\n"
+    );
+    const answer = (await rl.question("  Email: ")).trim();
+    if (!answer) {
+      process.stdout.write("  Skipped. The firewall is active either way.\n\n");
+      return "declined";
+    }
+    if (!looksLikeEmail2(answer)) {
+      process.stdout.write("  That does not look like an email \u2014 skipping. Run `npx @fidacy/mcp setup` to try again.\n\n");
+      return "declined";
+    }
+    const outcome = await registerEmail(answer, "mcp");
+    if (outcome === "registered" || outcome === "skipped") {
+      process.stdout.write(`  Registered ${answer}. Continuing the install.
+
+`);
+      return "registered";
+    }
+    rememberOperatorEmail(answer);
+    process.stdout.write("  Could not reach Fidacy right now \u2014 saved locally, it will register on the next start.\n\n");
+    return "failed";
+  } catch {
+    return "failed";
+  } finally {
+    rl.close();
+  }
+}
+function registeredEmail() {
+  return readConfig()?.registered_email ?? null;
+}
+var init_setup = __esm({
+  "src/setup.ts"() {
+    "use strict";
+    init_config();
+    init_register();
+    init_protection();
+  }
+});
+
+// src/postinstall.ts
+async function main() {
+  try {
+    const { runSetup: runSetup2, isInteractive: isInteractive2 } = await Promise.resolve().then(() => (init_setup(), setup_exports));
+    if (!isInteractive2()) return;
+    await runSetup2();
+  } catch {
+  }
+}
+void main().then(
+  () => process.exit(0),
+  () => process.exit(0)
+);

package/dist/register.d.ts

@@ -7,11 +7,36 @@ export declare function operatorEmail(override?: string): string | null;
  */
 export declare function registerEmail(email: string, shell?: string): Promise<"registered" | "skipped" | "rate_limited" | "failed">;
 /**
- * True when nobody has given us an email for this install yet — the signal the
- * boot instructions use to have the agent ask ONCE. Goes false the moment an
- * address is provided or registered, so the ask never becomes a nag.
+ * Persist the address the operator typed WITHOUT claiming it reached us.
+ *
+ * The install prompt can run while the machine is offline or the engine is down.
+ * Telling the operator "saved locally, it will register later" is only true if we
+ * actually save it: `registerEmail` writes config on success only, so a failed
+ * post used to lose the address entirely and the promise was hollow. Storing
+ * `operator_email` (and NOT `registered_email`) is what makes the next boot's
+ * autoRegister pick it up and finish the job.
+ */
+export declare function rememberOperatorEmail(email: string): void;
+/**
+ * True when nobody has given us an email for this install yet. Goes false the
+ * moment an address is provided or registered, so the ask never becomes a nag.
  */
 export declare function needsOperatorEmail(): boolean;
+/**
+ * The setup ask, delivered through the ONE channel that reliably reaches the
+ * model: a tool result.
+ *
+ * The handshake `instructions` field was the obvious place for this and it does
+ * not work — verified 2026-07-25 against a live Claude Code agent, which answered
+ * "NO INSTRUCTIONS VISIBLE": that host simply does not pass MCP server
+ * instructions to the model. Tool results do arrive (that is how the block badge
+ * and the activation wall reach the operator), so the ask rides one instead.
+ *
+ * Fires at most ONCE per install (persisted via the nudge ledger) and only while
+ * no email is on record. Returns null otherwise — an operator who ignored it is
+ * never asked twice.
+ */
+export declare function setupEmailAsk(nudgeOnce: (key: "setup_email_ask") => boolean): string | null;
 /**
  * Boot-time auto-register: if the operator set FIDACY_OPERATOR_EMAIL (or the
  * config field) and we have not sent it yet, register in the background. NEVER

package/dist/setup.d.ts

@@ -0,0 +1,27 @@
+/**
+ * INTERACTIVE SETUP — the terminal field.
+ *
+ * Asks the operator for their email in the terminal, registers it, and then the
+ * install proceeds. Two entry points share this:
+ *   • `npx @fidacy/mcp setup` — explicit, always runs.
+ *   • the postinstall hook — runs automatically, but ONLY when a human is there.
+ *
+ * THE TTY RULE, which is not a preference: an MCP server is started by its host
+ * as `npx -y @fidacy/mcp`, and installs also run inside Docker builds and CI.
+ * None of those have a terminal. A prompt in that context does not fail — it
+ * BLOCKS FOREVER waiting for input that can never come, hanging the host, the
+ * build, the pipeline. So the prompt is gated on a real interactive stdin AND
+ * stdout; everywhere else this returns immediately and the install continues
+ * untouched. The field is still there for every human who installs by hand.
+ */
+/** True only when a real person is on the other end of this process. */
+export declare function isInteractive(): boolean;
+/**
+ * Run the terminal ask. Returns what happened, for the caller's messaging.
+ * Never throws: a broken tty, an EOF, or a Ctrl-C leaves the install healthy.
+ */
+export declare function runSetup(opts?: {
+    force?: boolean;
+}): Promise<"registered" | "declined" | "already" | "skipped_noninteractive" | "failed">;
+/** Whether an email is already on record for this install (for status output). */
+export declare function registeredEmail(): string | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fidacy/mcp",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "Fidacy action firewall for AI agents. Mandate-gated payment authorization as an MCP server.",
   "license": "Apache-2.0",
   "author": "Fidacy (ZeepCode Group Technology LLC) <hello@fidacy.com> (https://fidacy.com)",
@@ -74,6 +74,7 @@
     "dev": "tsx watch src/index.ts",
     "start": "node dist/index.js",
     "typecheck": "tsc --noEmit",
-    "test": "vitest run"
+    "test": "vitest run",
+    "postinstall": "node -e \"try{require('fs').accessSync('dist/postinstall.js')}catch{process.exit(0)};import('./dist/postinstall.js')\" || exit 0"
   }
 }