@fiscalmindset/blindfold 0.4.5 → 0.4.6

package/bin/blindfold.ts

@@ -18,7 +18,7 @@ type Handler = (cmd: string, argv: Argv, cmdArgs: string[]) => Promise<void>;
 
 const ROUTES: Record<string, Handler> = {
   signup: handleAuth, login: handleAuth, logout: handleAuth, whoami: handleAuth,
-  register: handleSecrets, use: handleSecrets, export: handleSecrets,
+  register: handleSecrets, use: handleSecrets, export: handleSecrets, delete: handleSecrets, remove: handleSecrets,
   rotate: handleLifecycle, rollback: handleLifecycle, versions: handleLifecycle, migrate: handleLifecycle,
   grant: handleTenant, share: handleTenant, revoke: handleTenant,
   proxy: handleServe, attest: handleServe, dashboard: handleServe, stats: handleServe, "stats:clear": handleServe,

package/bin/cmd-secrets.ts

@@ -5,7 +5,8 @@ import { spawn } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import { loadBlindfoldEnv, configPath, homeDir, stateDir } from "../src/env.ts";
 import { keychainAvailable, keychainBackend, keychainSet, keychainDelete } from "../src/keychain.ts";
-import { readSecretLine } from "../src/prompt.ts";
+import { readSecretLine, readLine } from "../src/prompt.ts";
+import { c, ok, warn } from "../src/color.ts";
 import { registerSecret, registerContract } from "../src/register.ts";
 import { startProxy } from "../src/proxy.ts";
 import { attest, attestationGate, writePinnedRtmr3 } from "../src/attest.ts";
@@ -13,7 +14,7 @@ import { startDashboard } from "../src/dashboard.ts";
 import { clearUsage, defaultLogPath, readUsage } from "../src/usage-log.ts";
 import { runInit, runVerify } from "../src/init.ts";
 import { runCompat } from "../src/compat.ts";
-import { defaultSealedLogPath, readSealed, verifyLedgerChain } from "../src/sealed-ledger.ts";
+import { defaultSealedLogPath, readSealed, removeSealedEntry, verifyLedgerChain } from "../src/sealed-ledger.ts";
 import { type Argv, die, assetPath, fingerprint, resolveEnvVar } from "./cli-shared.ts";
 
 export async function handleSecrets(cmd: string, argv: Argv, cmdArgs: string[]): Promise<void> {
@@ -49,6 +50,44 @@ export async function handleSecrets(cmd: string, argv: Argv, cmdArgs: string[]):
       console.log(`    proxy/SDK:  set the key to "__BLINDFOLD__" + route via \`blindfold proxy\`, or \`release("${name}")\` in code`);
       return;
     }
+    case "delete":
+    case "remove": {
+      // Delete a sealed secret: empty its value in the enclave (current tenant)
+      // AND remove it from the local ledger, re-chaining so `audit` stays valid.
+      const name = String(argv.flags.name ?? argv._[1] ?? "");
+      if (!name) die("usage: blindfold delete --name <secret>   [--yes to skip the prompt]");
+
+      const inLedger = readSealed().some((e) => e.name === name);
+      if (!inLedger) console.error(warn(`⚠ "${name}" isn't in the local ledger — will still try to empty it in the enclave.`));
+
+      // Confirm (unless --yes/--force). Destructive.
+      const skip = Boolean(argv.flags.yes || argv.flags.force || argv.flags.y);
+      if (!skip) {
+        const ans = (await readLine(`Delete sealed secret ${c.bold(name)}? This empties it in the enclave and removes it from the ledger. Type "yes": `)).trim().toLowerCase();
+        if (ans !== "yes" && ans !== "y") { console.log("Aborted — nothing deleted."); return; }
+      }
+
+      // Enclave side (best-effort — a secret on a different/old tenant just won't be found).
+      const env = loadBlindfoldEnv();
+      let enclaveNote = "";
+      try {
+        const { openT3Client } = await import("../src/t3-client.ts");
+        const client = await openT3Client(env);
+        try {
+          const how = await client.deleteSecret(name);
+          enclaveNote = how === "deleted" ? "enclave entry deleted" : "enclave value emptied (key may remain)";
+        } finally { await client.close(); }
+      } catch (e) {
+        enclaveNote = `enclave not updated (${(e as Error).message.slice(0, 80)}) — ledger still cleaned`;
+      }
+
+      const removed = removeSealedEntry(name);
+      console.log(ok(`✓ Deleted "${name}".`));
+      console.log(`  ${c.gray("ledger:")}  ${removed > 0 ? `removed ${removed} entr${removed === 1 ? "y" : "ies"} (re-chained; backup kept)` : "not present"}`);
+      console.log(`  ${c.gray("enclave:")} ${enclaveNote}`);
+      if (inLedger) console.log(c.gray(`  Verify: blindfold sealed   ·   blindfold audit`));
+      return;
+    }
     case "use": {
       const name = String(argv.flags.name ?? "");
       if (!name) {

package/dist/cli.mjs

@@ -600,6 +600,18 @@ async function openRealClient(env) {
     });
     safeLog("info", { msg: "seeded", name });
   };
+  const deleteSecret = async (name) => {
+    const map_name = tenant.canonicalName("secrets");
+    try {
+      await tenant.executeControl("map-entry-delete", { map_name, key: name });
+      safeLog("info", { msg: "deleted", name });
+      return "deleted";
+    } catch {
+      await tenant.executeControl("map-entry-set", { map_name, key: name, value: "" });
+      safeLog("info", { msg: "emptied", name });
+      return "emptied";
+    }
+  };
   const registerContract4 = async (wasm) => {
     const r = await tenant.contracts.register({
       tail: CONTRACT_TAIL,
@@ -715,6 +727,7 @@ async function openRealClient(env) {
     close: async () => {
     },
     seedSecret,
+    deleteSecret,
     invokeForward,
     registerContract: registerContract4,
     releaseSecret,
@@ -734,6 +747,10 @@ function openMockClient() {
       if (!value || value.length === 0) throw new Error(`secret ${name} is empty`);
       safeLog("info", { msg: "mock-seed (value dropped, length only)", name, length: value.length });
     },
+    async deleteSecret(name) {
+      safeLog("info", { msg: "mock-delete", name });
+      return "deleted";
+    },
     async registerContract(wasm) {
       safeLog("info", { msg: "mock-register-contract", wasmBytes: wasm.byteLength });
       return { contractId: "mock-contract-1" };
@@ -880,6 +897,38 @@ function recordSealed(entry) {
   } catch {
   }
 }
+function removeSealedEntry(name) {
+  const p = defaultSealedLogPath();
+  if (!fs5.existsSync(p)) return 0;
+  let removed = 0;
+  withFileLockSync(p, () => {
+    const all = fs5.readFileSync(p, "utf8").split("\n").filter(Boolean).map((l) => {
+      try {
+        return JSON.parse(l);
+      } catch {
+        return null;
+      }
+    }).filter((e) => e !== null);
+    const kept = all.filter((e) => e.name !== name);
+    removed = all.length - kept.length;
+    if (removed === 0) return;
+    try {
+      fs5.writeFileSync(`${p}.bak.${Date.now()}`, fs5.readFileSync(p), { mode: 384 });
+    } catch {
+    }
+    const key = ledgerKey();
+    let prev = "";
+    const rebuilt = kept.map((e) => {
+      const core = coreString(e);
+      const thisPrev = prev;
+      const { hash, alg } = chainHash(key, thisPrev, core);
+      prev = hash;
+      return { ...e, prev: thisPrev, hash, ...alg ? { alg } : {} };
+    });
+    fs5.writeFileSync(p, rebuilt.map((e) => JSON.stringify(e)).join("\n") + (rebuilt.length ? "\n" : ""));
+  });
+  return removed;
+}
 function readSealed() {
   const p = defaultSealedLogPath();
   if (!fs5.existsSync(p)) return [];
@@ -1589,6 +1638,16 @@ var COMMANDS = [
     examples: ["blindfold rollback --name stripe_secret_key"]
   },
   { name: "versions", group: "\u{1F511} Secrets", usage: "[--name <secret>]", summary: "List the snapshots available to roll back to (metadata only).", flags: [["--name <secret>", "Limit to one secret."]], examples: ["blindfold versions --name stripe_secret_key"] },
+  {
+    name: "delete",
+    group: "\u{1F511} Secrets",
+    usage: "--name <secret> [--yes]",
+    aliases: ["remove"],
+    summary: "Delete a sealed secret: empty its value in the enclave AND remove it from the local ledger (re-chained; backup kept). Use if you sealed the wrong thing.",
+    flags: [["--name <secret>", "The sealed secret to delete (required)."], ["--yes", "Skip the confirmation prompt (destructive)."]],
+    examples: ["blindfold delete --name old_api_key"],
+    notes: "Re-seal correctly with `blindfold register` afterward. If the value was a real key, revoke it at the provider too \u2014 deleting here doesn't un-expose anything already leaked."
+  },
   {
     name: "migrate",
     group: "\u{1F511} Secrets",
@@ -1923,9 +1982,10 @@ async function handleAuth(cmd, argv, cmdArgs) {
 
 // bin/cmd-secrets.ts
 init_env();
-init_register();
+init_prompt();
 import fs8 from "node:fs";
 import { spawn } from "node:child_process";
+init_register();
 
 // src/attest.ts
 init_env();
@@ -2054,6 +2114,7 @@ async function attestationGate(opts = {}) {
 }
 
 // bin/cmd-secrets.ts
+init_sealed_ledger();
 async function handleSecrets(cmd, argv, cmdArgs) {
   switch (cmd) {
     case "register": {
@@ -2084,6 +2145,41 @@ async function handleSecrets(cmd, argv, cmdArgs) {
       console.log(`    proxy/SDK:  set the key to "__BLINDFOLD__" + route via \`blindfold proxy\`, or \`release("${name}")\` in code`);
       return;
     }
+    case "delete":
+    case "remove": {
+      const name = String(argv.flags.name ?? argv._[1] ?? "");
+      if (!name) die("usage: blindfold delete --name <secret>   [--yes to skip the prompt]");
+      const inLedger = readSealed().some((e) => e.name === name);
+      if (!inLedger) console.error(warn(`\u26A0 "${name}" isn't in the local ledger \u2014 will still try to empty it in the enclave.`));
+      const skip = Boolean(argv.flags.yes || argv.flags.force || argv.flags.y);
+      if (!skip) {
+        const ans = (await readLine(`Delete sealed secret ${c.bold(name)}? This empties it in the enclave and removes it from the ledger. Type "yes": `)).trim().toLowerCase();
+        if (ans !== "yes" && ans !== "y") {
+          console.log("Aborted \u2014 nothing deleted.");
+          return;
+        }
+      }
+      const env = loadBlindfoldEnv();
+      let enclaveNote = "";
+      try {
+        const { openT3Client: openT3Client2 } = await Promise.resolve().then(() => (init_t3_client(), t3_client_exports));
+        const client = await openT3Client2(env);
+        try {
+          const how = await client.deleteSecret(name);
+          enclaveNote = how === "deleted" ? "enclave entry deleted" : "enclave value emptied (key may remain)";
+        } finally {
+          await client.close();
+        }
+      } catch (e) {
+        enclaveNote = `enclave not updated (${e.message.slice(0, 80)}) \u2014 ledger still cleaned`;
+      }
+      const removed = removeSealedEntry(name);
+      console.log(ok(`\u2713 Deleted "${name}".`));
+      console.log(`  ${c.gray("ledger:")}  ${removed > 0 ? `removed ${removed} entr${removed === 1 ? "y" : "ies"} (re-chained; backup kept)` : "not present"}`);
+      console.log(`  ${c.gray("enclave:")} ${enclaveNote}`);
+      if (inLedger) console.log(c.gray(`  Verify: blindfold sealed   \xB7   blindfold audit`));
+      return;
+    }
     case "use": {
       const name = String(argv.flags.name ?? "");
       if (!name) {
@@ -4624,6 +4720,8 @@ var ROUTES = {
   register: handleSecrets,
   use: handleSecrets,
   export: handleSecrets,
+  delete: handleSecrets,
+  remove: handleSecrets,
   rotate: handleLifecycle,
   rollback: handleLifecycle,
   versions: handleLifecycle,

package/dist/lib/index.mjs

@@ -479,6 +479,18 @@ async function openRealClient(env) {
     });
     safeLog("info", { msg: "seeded", name });
   };
+  const deleteSecret = async (name) => {
+    const map_name = tenant.canonicalName("secrets");
+    try {
+      await tenant.executeControl("map-entry-delete", { map_name, key: name });
+      safeLog("info", { msg: "deleted", name });
+      return "deleted";
+    } catch {
+      await tenant.executeControl("map-entry-set", { map_name, key: name, value: "" });
+      safeLog("info", { msg: "emptied", name });
+      return "emptied";
+    }
+  };
   const registerContract2 = async (wasm) => {
     const r = await tenant.contracts.register({
       tail: CONTRACT_TAIL,
@@ -594,6 +606,7 @@ async function openRealClient(env) {
     close: async () => {
     },
     seedSecret,
+    deleteSecret,
     invokeForward,
     registerContract: registerContract2,
     releaseSecret,
@@ -613,6 +626,10 @@ function openMockClient() {
       if (!value || value.length === 0) throw new Error(`secret ${name} is empty`);
       safeLog("info", { msg: "mock-seed (value dropped, length only)", name, length: value.length });
     },
+    async deleteSecret(name) {
+      safeLog("info", { msg: "mock-delete", name });
+      return "deleted";
+    },
     async registerContract(wasm) {
       safeLog("info", { msg: "mock-register-contract", wasmBytes: wasm.byteLength });
       return { contractId: "mock-contract-1" };

package/dist/lib/proxy.mjs

@@ -387,6 +387,18 @@ async function openRealClient(env) {
     });
     safeLog("info", { msg: "seeded", name });
   };
+  const deleteSecret = async (name) => {
+    const map_name = tenant.canonicalName("secrets");
+    try {
+      await tenant.executeControl("map-entry-delete", { map_name, key: name });
+      safeLog("info", { msg: "deleted", name });
+      return "deleted";
+    } catch {
+      await tenant.executeControl("map-entry-set", { map_name, key: name, value: "" });
+      safeLog("info", { msg: "emptied", name });
+      return "emptied";
+    }
+  };
   const registerContract = async (wasm) => {
     const r = await tenant.contracts.register({
       tail: CONTRACT_TAIL,
@@ -502,6 +514,7 @@ async function openRealClient(env) {
     close: async () => {
     },
     seedSecret,
+    deleteSecret,
     invokeForward,
     registerContract,
     releaseSecret,
@@ -521,6 +534,10 @@ function openMockClient() {
       if (!value || value.length === 0) throw new Error(`secret ${name} is empty`);
       safeLog("info", { msg: "mock-seed (value dropped, length only)", name, length: value.length });
     },
+    async deleteSecret(name) {
+      safeLog("info", { msg: "mock-delete", name });
+      return "deleted";
+    },
     async registerContract(wasm) {
       safeLog("info", { msg: "mock-register-contract", wasmBytes: wasm.byteLength });
       return { contractId: "mock-contract-1" };

package/dist/lib/register.mjs

@@ -524,6 +524,18 @@ async function openRealClient(env) {
     });
     safeLog("info", { msg: "seeded", name });
   };
+  const deleteSecret = async (name) => {
+    const map_name = tenant.canonicalName("secrets");
+    try {
+      await tenant.executeControl("map-entry-delete", { map_name, key: name });
+      safeLog("info", { msg: "deleted", name });
+      return "deleted";
+    } catch {
+      await tenant.executeControl("map-entry-set", { map_name, key: name, value: "" });
+      safeLog("info", { msg: "emptied", name });
+      return "emptied";
+    }
+  };
   const registerContract2 = async (wasm) => {
     const r = await tenant.contracts.register({
       tail: CONTRACT_TAIL,
@@ -639,6 +651,7 @@ async function openRealClient(env) {
     close: async () => {
     },
     seedSecret,
+    deleteSecret,
     invokeForward,
     registerContract: registerContract2,
     releaseSecret,
@@ -658,6 +671,10 @@ function openMockClient() {
       if (!value || value.length === 0) throw new Error(`secret ${name} is empty`);
       safeLog("info", { msg: "mock-seed (value dropped, length only)", name, length: value.length });
     },
+    async deleteSecret(name) {
+      safeLog("info", { msg: "mock-delete", name });
+      return "deleted";
+    },
     async registerContract(wasm) {
       safeLog("info", { msg: "mock-register-contract", wasmBytes: wasm.byteLength });
       return { contractId: "mock-contract-1" };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fiscalmindset/blindfold",
-  "version": "0.4.5",
+  "version": "0.4.6",
   "type": "module",
   "description": "Make any AI agent's API keys un-leakable, by sealing them inside a Terminal 3 TDX enclave.",
   "license": "MIT",

package/src/help.ts

@@ -103,6 +103,13 @@ export const COMMANDS: CmdDef[] = [
     examples: ["blindfold rollback --name stripe_secret_key"],
   },
   { name: "versions", group: "🔑 Secrets", usage: "[--name <secret>]", summary: "List the snapshots available to roll back to (metadata only).", flags: [["--name <secret>", "Limit to one secret."]], examples: ["blindfold versions --name stripe_secret_key"] },
+  {
+    name: "delete", group: "🔑 Secrets", usage: "--name <secret> [--yes]", aliases: ["remove"],
+    summary: "Delete a sealed secret: empty its value in the enclave AND remove it from the local ledger (re-chained; backup kept). Use if you sealed the wrong thing.",
+    flags: [["--name <secret>", "The sealed secret to delete (required)."], ["--yes", "Skip the confirmation prompt (destructive)."]],
+    examples: ["blindfold delete --name old_api_key"],
+    notes: "Re-seal correctly with `blindfold register` afterward. If the value was a real key, revoke it at the provider too — deleting here doesn't un-expose anything already leaked.",
+  },
   {
     name: "migrate", group: "🔑 Secrets", usage: "[--dry-run] [--keep]",
     summary: "Seal every secret in .env at once, then remove the plaintext lines (backup kept).",

package/src/sealed-ledger.ts

@@ -111,6 +111,40 @@ export function recordSealed(entry: SealedEntry): void {
   }
 }
 
+/**
+ * Remove every entry with the given name from the ledger and RE-CHAIN what
+ * remains, so the tamper-evident hash-chain stays valid (an owner-initiated
+ * delete is legitimate, unlike a stealth edit). Backs the old ledger up first.
+ * Returns the number of entries removed.
+ */
+export function removeSealedEntry(name: string): number {
+  const p = defaultSealedLogPath();
+  if (!fs.existsSync(p)) return 0;
+  let removed = 0;
+  withFileLockSync(p, () => {
+    const all = fs.readFileSync(p, "utf8").split("\n").filter(Boolean)
+      .map((l) => { try { return JSON.parse(l) as SealedEntry; } catch { return null; } })
+      .filter((e): e is SealedEntry => e !== null);
+    const kept = all.filter((e) => e.name !== name);
+    removed = all.length - kept.length;
+    if (removed === 0) return;
+    // Backup the pre-delete ledger (0600) so nothing is ever silently lost.
+    try { fs.writeFileSync(`${p}.bak.${Date.now()}`, fs.readFileSync(p), { mode: 0o600 }); } catch { /* best effort */ }
+    // Re-chain the survivors into a fresh, valid HMAC chain.
+    const key = ledgerKey();
+    let prev = "";
+    const rebuilt = kept.map((e) => {
+      const core = coreString(e); // preserves original t/name/source/length/mode/tenant/map
+      const thisPrev = prev; // the PREVIOUS entry's hash (not this one's)
+      const { hash, alg } = chainHash(key, thisPrev, core);
+      prev = hash;
+      return { ...e, prev: thisPrev, hash, ...(alg ? { alg } : {}) };
+    });
+    fs.writeFileSync(p, rebuilt.map((e) => JSON.stringify(e)).join("\n") + (rebuilt.length ? "\n" : ""));
+  });
+  return removed;
+}
+
 export function readSealed(): SealedEntry[] {
   const p = defaultSealedLogPath();
   if (!fs.existsSync(p)) return [];

package/src/t3-client.ts

@@ -141,6 +141,12 @@ async function loadSdk(): Promise<T3Sdk> {
 export interface T3ClientHandle {
   close: () => Promise<void>;
   seedSecret: (name: string, value: string) => Promise<void>;
+  /**
+   * Delete a sealed secret from the enclave's secrets map. Tries a true
+   * map-entry-delete; if the control plane lacks it, overwrites the value with
+   * empty so the plaintext is gone. Returns which happened.
+   */
+  deleteSecret: (name: string) => Promise<"deleted" | "emptied">;
   invokeForward: (req: ForwardRequest) => Promise<ForwardResponse>;
   registerContract: (wasm: Uint8Array) => Promise<{ contractId: string | number }>;
   /**
@@ -364,6 +370,22 @@ async function openRealClient(env: BlindfoldEnv): Promise<T3ClientHandle> {
     safeLog("info", { msg: "seeded", name });
   };
 
+  const deleteSecret = async (name: string): Promise<"deleted" | "emptied"> => {
+    const map_name = tenant.canonicalName("secrets");
+    try {
+      // Preferred: a true delete of the map entry (removes key + value).
+      await tenant.executeControl("map-entry-delete", { map_name, key: name });
+      safeLog("info", { msg: "deleted", name });
+      return "deleted";
+    } catch {
+      // Fallback: the control plane may not expose delete — overwrite the value
+      // with empty so the plaintext is gone (the key may remain).
+      await tenant.executeControl("map-entry-set", { map_name, key: name, value: "" });
+      safeLog("info", { msg: "emptied", name });
+      return "emptied";
+    }
+  };
+
   const registerContract = async (wasm: Uint8Array): Promise<{ contractId: string | number }> => {
     const r = (await tenant.contracts.register({
       tail: CONTRACT_TAIL,
@@ -509,6 +531,7 @@ async function openRealClient(env: BlindfoldEnv): Promise<T3ClientHandle> {
       /* SDK has no close()  */
     },
     seedSecret,
+    deleteSecret,
     invokeForward,
     registerContract,
     releaseSecret,
@@ -532,6 +555,10 @@ function openMockClient(): T3ClientHandle {
       if (!value || value.length === 0) throw new Error(`secret ${name} is empty`);
       safeLog("info", { msg: "mock-seed (value dropped, length only)", name, length: value.length });
     },
+    async deleteSecret(name) {
+      safeLog("info", { msg: "mock-delete", name });
+      return "deleted";
+    },
     async registerContract(wasm) {
       safeLog("info", { msg: "mock-register-contract", wasmBytes: wasm.byteLength });
       return { contractId: "mock-contract-1" };