@attest-it/cli 0.8.0 → 0.9.1

package/dist/index.cjs

@@ -3,6 +3,7 @@
 var commander = require('commander');
 var fs = require('fs');
 var path = require('path');
+var url = require('url');
 var chromaterm = require('chromaterm');
 var prompts = require('@inquirer/prompts');
 var core = require('@attest-it/core');
@@ -14,9 +15,7 @@ var React7 = require('react');
 var ink = require('ink');
 var jsxRuntime = require('react/jsx-runtime');
 var promises = require('fs/promises');
-var ui = require('@inkjs/ui');
 var yaml = require('yaml');
-var url = require('url');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -278,47 +277,93 @@ async function offerCompletionInstall() {
     return false;
   }
 }
+function hasVersion(data) {
+  return typeof data === "object" && data !== null && "version" in data && // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  typeof data.version === "string";
+}
+var cachedVersion;
+function getPackageVersion() {
+  if (cachedVersion !== void 0) {
+    return cachedVersion;
+  }
+  const __filename = url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+  const __dirname = path.dirname(__filename);
+  const possiblePaths = [path.join(__dirname, "../package.json"), path.join(__dirname, "../../package.json")];
+  for (const packageJsonPath of possiblePaths) {
+    try {
+      const content = fs.readFileSync(packageJsonPath, "utf-8");
+      const packageJsonData = JSON.parse(content);
+      if (!hasVersion(packageJsonData)) {
+        throw new Error(`Invalid package.json at ${packageJsonPath}: missing version field`);
+      }
+      cachedVersion = packageJsonData.version;
+      return cachedVersion;
+    } catch (error2) {
+      if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT") {
+        continue;
+      }
+      throw error2;
+    }
+  }
+  throw new Error("Could not find package.json");
+}
 
 // src/commands/init.ts
 var initCommand = new commander.Command("init").description("Initialize attest-it configuration").option("-p, --path <path>", "Config file path", ".attest-it/config.yaml").option("-f, --force", "Overwrite existing config").action(async (options) => {
   await runInit(options);
 });
-var CONFIG_TEMPLATE = `# attest-it configuration
-# See https://github.com/attest-it/attest-it for documentation
-
-version: 1
-
-settings:
-  # How long attestations remain valid (in days)
-  maxAgeDays: 30
-  # Path to the public key used for signature verification
-  publicKeyPath: .attest-it/pubkey.pem
-  # Path to the attestations file
-  attestationsPath: .attest-it/attestations.json
-  # Signing algorithm
-  algorithm: rsa
-
-# Define your test suites below. Each suite groups tests that require
-# human verification before their attestations are accepted.
-#
-# Example:
-#
-# suites:
-#   visual-tests:
-#     description: Visual regression tests requiring human review
-#     packages:
-#       - packages/ui
-#       - packages/components
-#     command: pnpm vitest packages/ui packages/components
-#
-#   integration:
-#     description: Integration tests with external services
-#     packages:
-#       - packages/api
-#     command: pnpm vitest packages/api --project=integration
-
-suites: {}
-`;
+function loadConfigTemplate() {
+  const __filename = url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+  const __dirname = path.dirname(__filename);
+  const possiblePaths = [
+    path.join(__dirname, "../../templates/config.yaml"),
+    path.join(__dirname, "../templates/config.yaml")
+  ];
+  for (const templatePath of possiblePaths) {
+    try {
+      return fs__namespace.readFileSync(templatePath, "utf-8");
+    } catch (error2) {
+      if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT") {
+        continue;
+      }
+      throw error2;
+    }
+  }
+  throw new Error("Could not find config.yaml template");
+}
+function isPackageJson(data) {
+  return typeof data === "object" && data !== null && "name" in data && "version" in data && // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  typeof data.name === "string" && // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  typeof data.version === "string";
+}
+function detectPackageManager() {
+  if (fs__namespace.existsSync("pnpm-lock.yaml")) return "pnpm";
+  if (fs__namespace.existsSync("yarn.lock")) return "yarn";
+  if (fs__namespace.existsSync("bun.lockb")) return "bun";
+  return "npm";
+}
+async function ensureDevDependency() {
+  const packageJsonPath = "package.json";
+  const packageManager = detectPackageManager();
+  let created = false;
+  let packageJson;
+  if (fs__namespace.existsSync(packageJsonPath)) {
+    const content = await fs__namespace.promises.readFile(packageJsonPath, "utf8");
+    const parsed = JSON.parse(content);
+    if (!isPackageJson(parsed)) {
+      throw new Error("Invalid package.json: missing required name or version field");
+    }
+    packageJson = parsed;
+  } else {
+    packageJson = { name: path__namespace.basename(process.cwd()), version: "1.0.0" };
+    created = true;
+  }
+  const devDeps = packageJson.devDependencies ?? {};
+  devDeps["attest-it"] = "^" + getPackageVersion();
+  packageJson.devDependencies = devDeps;
+  await fs__namespace.promises.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n");
+  return { packageManager, created };
+}
 async function runInit(options) {
   try {
     const configPath = path__namespace.resolve(options.path);
@@ -333,14 +378,22 @@ async function runInit(options) {
         process.exit(ExitCode.CANCELLED);
       }
     }
+    const { packageManager, created } = await ensureDevDependency();
+    if (created) {
+      success("Created package.json");
+    } else {
+      success("Updated package.json with attest-it devDependency");
+    }
     await fs__namespace.promises.mkdir(configDir, { recursive: true });
-    await fs__namespace.promises.writeFile(configPath, CONFIG_TEMPLATE, "utf-8");
+    const configTemplate = loadConfigTemplate();
+    await fs__namespace.promises.writeFile(configPath, configTemplate, "utf-8");
     success(`Configuration created at ${configPath}`);
     log("");
     log("Next steps:");
-    log(`  1. Edit ${options.path} to define your test suites`);
-    log("  2. Run: attest-it keygen");
-    log("  3. Run: attest-it status");
+    log(`  1. Run: ${packageManager} install`);
+    log("  2. Run: attest-it identity create  (if you haven't already)");
+    log("  3. Run: attest-it team join");
+    log("  4. Edit .attest-it/config.yaml to define your gates and suites");
     await offerCompletionInstall();
   } catch (err) {
     if (err instanceof Error) {
@@ -572,14 +625,14 @@ function SelectionPrompt({
   onSelect,
   groups
 }) {
-  ink.useInput((input5) => {
-    const matchedOption = options.find((opt) => opt.hint === input5);
+  ink.useInput((input4) => {
+    const matchedOption = options.find((opt) => opt.hint === input4);
     if (matchedOption) {
       onSelect(matchedOption.value);
       return;
     }
     if (groups) {
-      const matchedGroup = groups.find((group) => group.name === input5);
+      const matchedGroup = groups.find((group) => group.name === input4);
       if (matchedGroup) {
         onSelect(matchedGroup.name);
       }
@@ -629,17 +682,17 @@ function SuiteSelector({
       return next;
     });
   }, []);
-  ink.useInput((input5, key) => {
-    if (input5 === "a") {
+  ink.useInput((input4, key) => {
+    if (input4 === "a") {
       setSelectedSuites(new Set(pendingSuites.map((s) => s.name)));
       return;
     }
-    if (input5 === "n") {
+    if (input4 === "n") {
       onExit();
       return;
     }
-    if (/^[1-9]$/.test(input5)) {
-      const idx = parseInt(input5, 10) - 1;
+    if (/^[1-9]$/.test(input4)) {
+      const idx = parseInt(input4, 10) - 1;
       if (idx < pendingSuites.length) {
         const suite = pendingSuites[idx];
         if (suite) {
@@ -648,8 +701,8 @@ function SuiteSelector({
       }
       return;
     }
-    if (input5.startsWith("g") && groups) {
-      const groupIdx = parseInt(input5.slice(1), 10) - 1;
+    if (input4.startsWith("g") && groups) {
+      const groupIdx = parseInt(input4.slice(1), 10) - 1;
       const groupNames = Object.keys(groups);
       if (groupIdx >= 0 && groupIdx < groupNames.length) {
         const groupName = groupNames[groupIdx];
@@ -666,7 +719,7 @@ function SuiteSelector({
       onSelect(Array.from(selectedSuites));
       return;
     }
-    if (input5 === " ") {
+    if (input4 === " ") {
       const currentSuite = pendingSuites[cursorIndex];
       if (currentSuite) {
         toggleSuite(currentSuite.name);
@@ -799,11 +852,11 @@ function TestRunner({
     };
   }, [currentIndex, phase, suites, executeTest, onComplete]);
   ink.useInput(
-    (input5, key) => {
+    (input4, key) => {
       if (phase !== "confirming") return;
       const currentSuite2 = suites[currentIndex];
       if (!currentSuite2) return;
-      if (input5.toLowerCase() === "y" || key.return) {
+      if (input4.toLowerCase() === "y" || key.return) {
         createAttestation3(currentSuite2).then(() => {
           setResults((prev) => ({
             ...prev,
@@ -820,7 +873,7 @@ function TestRunner({
           setPhase("running");
         });
       }
-      if (input5.toLowerCase() === "n") {
+      if (input4.toLowerCase() === "n") {
         setResults((prev) => ({
           ...prev,
           skipped: [...prev.skipped, currentSuite2]
@@ -1533,9 +1586,9 @@ async function runSingleSuite(suiteName, config, options) {
   if (!await keyProvider.keyExists(keyRef)) {
     error(`Private key not found in ${keyProvider.displayName}`);
     if (keyProvider.type === "filesystem") {
-      error('Run "attest-it keygen" first to generate a keypair.');
+      error('Run "attest-it identity create" first to generate a keypair.');
     } else {
-      error('Run "attest-it keygen" to generate and store a key.');
+      error('Run "attest-it identity create" to generate and store a key.');
     }
     process.exit(ExitCode.MISSING_KEY);
   }
@@ -1559,7 +1612,7 @@ async function promptForSeal(suiteName, gateId, config) {
   const localConfig = core.loadLocalConfigSync();
   if (!localConfig) {
     warn("No local identity configuration found - cannot create seal");
-    warn('Run "attest-it keygen" to set up your identity');
+    warn('Run "attest-it identity create" to set up your identity');
     return;
   }
   const identity = core.getActiveIdentity(localConfig);
@@ -1594,8 +1647,8 @@ async function promptForSeal(suiteName, gateId, config) {
     const keyProvider = createKeyProviderFromIdentity(identity);
     const keyRef = getKeyRefFromIdentity(identity);
     const keyResult = await keyProvider.getPrivateKey(keyRef);
-    const fs4 = await import('fs/promises');
-    const privateKeyPem = await fs4.readFile(keyResult.keyPath, "utf8");
+    const fs3 = await import('fs/promises');
+    const privateKeyPem = await fs3.readFile(keyResult.keyPath, "utf8");
     await keyResult.cleanup();
     const identitySlug = localConfig.activeIdentity;
     const seal = core.createSeal({
@@ -1677,697 +1730,6 @@ function getKeyRefFromIdentity(identity) {
     }
   }
 }
-var MIN_PASSPHRASE_LENGTH = 8;
-function KeygenInteractive(props) {
-  const { onComplete, onCancel, onError } = props;
-  const [step, setStep] = React7.useState("checking-providers");
-  const [opAvailable, setOpAvailable] = React7.useState(false);
-  const [keychainAvailable, setKeychainAvailable] = React7.useState(false);
-  const [yubiKeyAvailable, setYubiKeyAvailable] = React7.useState(false);
-  const [accounts, setAccounts] = React7.useState([]);
-  const [vaults, setVaults] = React7.useState([]);
-  const [yubiKeyDevices, setYubiKeyDevices] = React7.useState([]);
-  const [_selectedProvider, setSelectedProvider] = React7.useState();
-  const [selectedAccount, setSelectedAccount] = React7.useState();
-  const [selectedVault, setSelectedVault] = React7.useState();
-  const [itemName, setItemName] = React7.useState("attest-it-private-key");
-  const [keychainItemName, setKeychainItemName] = React7.useState("attest-it-private-key");
-  const [selectedYubiKeySerial, setSelectedYubiKeySerial] = React7.useState();
-  const [selectedYubiKeySlot, setSelectedYubiKeySlot] = React7.useState(2);
-  const [slot1Configured, setSlot1Configured] = React7.useState(false);
-  const [slot2Configured, setSlot2Configured] = React7.useState(false);
-  const [encryptionPassphrase, setEncryptionPassphrase] = React7.useState();
-  ink.useInput((_input, key) => {
-    if (key.escape) {
-      onCancel();
-    }
-  });
-  React7.useEffect(() => {
-    const checkProviders = async () => {
-      try {
-        const isInstalled = await core.OnePasswordKeyProvider.isInstalled();
-        setOpAvailable(isInstalled);
-        if (isInstalled) {
-          const accountList = await core.OnePasswordKeyProvider.listAccounts();
-          setAccounts(accountList);
-        }
-      } catch {
-        setOpAvailable(false);
-      }
-      const isKeychainAvailable = core.MacOSKeychainKeyProvider.isAvailable();
-      setKeychainAvailable(isKeychainAvailable);
-      try {
-        const isInstalled = await core.YubiKeyProvider.isInstalled();
-        if (isInstalled) {
-          const isConnected = await core.YubiKeyProvider.isConnected();
-          if (isConnected) {
-            const devices = await core.YubiKeyProvider.listDevices();
-            setYubiKeyDevices(devices);
-            setYubiKeyAvailable(devices.length > 0);
-          }
-        }
-      } catch {
-        setYubiKeyAvailable(false);
-      }
-      setStep("select-provider");
-    };
-    void checkProviders();
-  }, []);
-  React7.useEffect(() => {
-    if (step === "select-vault" && selectedAccount) {
-      const fetchVaults = async () => {
-        try {
-          const vaultList = await core.OnePasswordKeyProvider.listVaults(selectedAccount);
-          setVaults(vaultList);
-        } catch (err) {
-          onError(err instanceof Error ? err : new Error("Failed to fetch vaults"));
-        }
-      };
-      void fetchVaults();
-    }
-  }, [step, selectedAccount, onError]);
-  const checkYubiKeySlots = async (serial) => {
-    try {
-      const slot1 = await core.YubiKeyProvider.isChallengeResponseConfigured(1, serial);
-      const slot2 = await core.YubiKeyProvider.isChallengeResponseConfigured(2, serial);
-      setSlot1Configured(slot1);
-      setSlot2Configured(slot2);
-      if (slot1 && slot2) {
-        setStep("select-yubikey-slot");
-      } else if (slot2) {
-        setSelectedYubiKeySlot(2);
-        void generateKeys("yubikey");
-      } else if (slot1) {
-        setSelectedYubiKeySlot(1);
-        void generateKeys("yubikey");
-      } else {
-        setStep("yubikey-offer-setup");
-      }
-    } catch (err) {
-      onError(err instanceof Error ? err : new Error("Failed to check YubiKey slots"));
-    }
-  };
-  const handleProviderSelect = (value) => {
-    if (value === "filesystem") {
-      setSelectedProvider("filesystem");
-      setStep("select-filesystem-encryption");
-    } else if (value === "1password") {
-      setSelectedProvider("1password");
-      if (accounts.length === 1 && accounts[0]) {
-        setSelectedAccount(accounts[0].user_uuid);
-        setStep("select-vault");
-      } else {
-        setStep("select-account");
-      }
-    } else if (value === "macos-keychain") {
-      setSelectedProvider("macos-keychain");
-      setStep("enter-keychain-item-name");
-    } else if (value === "yubikey") {
-      setSelectedProvider("yubikey");
-      if (yubiKeyDevices.length > 1) {
-        setStep("select-yubikey-device");
-      } else if (yubiKeyDevices.length === 1 && yubiKeyDevices[0]) {
-        setSelectedYubiKeySerial(yubiKeyDevices[0].serial);
-        void checkYubiKeySlots(yubiKeyDevices[0].serial);
-      }
-    }
-  };
-  const handleAccountSelect = (value) => {
-    setSelectedAccount(value);
-    setStep("select-vault");
-  };
-  const handleVaultSelect = (value) => {
-    setSelectedVault(value);
-    setStep("enter-item-name");
-  };
-  const handleItemNameSubmit = (value) => {
-    setItemName(value);
-    void generateKeys("1password");
-  };
-  const handleKeychainItemNameSubmit = (value) => {
-    setKeychainItemName(value);
-    void generateKeys("macos-keychain");
-  };
-  const handleYubiKeyDeviceSelect = (value) => {
-    setSelectedYubiKeySerial(value);
-    void checkYubiKeySlots(value);
-  };
-  const handleYubiKeySlotSelect = (value) => {
-    const slot = value === "1" ? 1 : 2;
-    setSelectedYubiKeySlot(slot);
-    void generateKeys("yubikey");
-  };
-  const handleYubiKeySetupConfirm = (value) => {
-    if (value === "yes") {
-      void setupYubiKeySlot();
-    } else {
-      onError(new Error("YubiKey setup cancelled"));
-    }
-  };
-  const handleEncryptionMethodSelect = (value) => {
-    if (value === "passphrase") {
-      setStep("enter-encryption-passphrase");
-    } else {
-      setEncryptionPassphrase(void 0);
-      void generateKeys("filesystem");
-    }
-  };
-  const handleEncryptionPassphrase = (value) => {
-    if (value.length < MIN_PASSPHRASE_LENGTH) {
-      onError(new Error(`Passphrase must be at least ${String(MIN_PASSPHRASE_LENGTH)} characters`));
-      return;
-    }
-    setEncryptionPassphrase(value);
-    setStep("confirm-encryption-passphrase");
-  };
-  const handleConfirmPassphrase = (value) => {
-    if (value !== encryptionPassphrase) {
-      onError(new Error("Passphrases do not match. Please try again."));
-      setEncryptionPassphrase(void 0);
-      setStep("enter-encryption-passphrase");
-      return;
-    }
-    void generateKeys("filesystem");
-  };
-  const setupYubiKeySlot = async () => {
-    setStep("yubikey-configuring");
-    try {
-      const { spawn: spawn3 } = await import('child_process');
-      const args = ["otp", "chalresp", "--touch", "--generate", "2"];
-      if (selectedYubiKeySerial) {
-        args.unshift("--device", selectedYubiKeySerial);
-      }
-      await new Promise((resolve2, reject) => {
-        const proc = spawn3("ykman", args, { stdio: "inherit" });
-        proc.on("close", (code) => {
-          if (code === 0) {
-            resolve2();
-          } else {
-            reject(new Error(`ykman exited with code ${String(code)}`));
-          }
-        });
-        proc.on("error", reject);
-      });
-      setSelectedYubiKeySlot(2);
-      void generateKeys("yubikey");
-    } catch (err) {
-      onError(err instanceof Error ? err : new Error("Failed to configure YubiKey"));
-    }
-  };
-  const generateKeys = async (provider) => {
-    setStep("generating");
-    try {
-      const publicKeyPath = props.publicKeyPath ?? core.getDefaultPublicKeyPath();
-      if (provider === "filesystem") {
-        const fsProvider = new core.FilesystemKeyProvider();
-        const genOptions = {
-          publicKeyPath
-        };
-        if (props.force !== void 0) {
-          genOptions.force = props.force;
-        }
-        if (encryptionPassphrase !== void 0) {
-          genOptions.passphrase = encryptionPassphrase;
-        }
-        const result = await fsProvider.generateKeyPair(genOptions);
-        const completionResult = {
-          provider: "filesystem",
-          publicKeyPath: result.publicKeyPath,
-          privateKeyRef: result.privateKeyRef,
-          storageDescription: result.storageDescription
-        };
-        if (result.encrypted) {
-          completionResult.encrypted = result.encrypted;
-        }
-        onComplete(completionResult);
-      } else if (provider === "1password") {
-        if (!selectedVault || !itemName) {
-          throw new Error("Vault and item name are required for 1Password");
-        }
-        const vault = vaults.find((v) => v.id === selectedVault);
-        if (!vault) {
-          throw new Error("Selected vault not found");
-        }
-        const providerOptions = {
-          vault: vault.name,
-          itemName
-        };
-        if (selectedAccount !== void 0) {
-          providerOptions.account = selectedAccount;
-        }
-        const opProvider = new core.OnePasswordKeyProvider(providerOptions);
-        const genOptions = { publicKeyPath };
-        if (props.force !== void 0) {
-          genOptions.force = props.force;
-        }
-        const result = await opProvider.generateKeyPair(genOptions);
-        const completionResult = {
-          provider: "1password",
-          publicKeyPath: result.publicKeyPath,
-          privateKeyRef: result.privateKeyRef,
-          storageDescription: result.storageDescription,
-          vault: vault.name,
-          itemName
-        };
-        if (selectedAccount !== void 0) {
-          completionResult.account = selectedAccount;
-        }
-        onComplete(completionResult);
-      } else if (provider === "macos-keychain") {
-        if (!keychainItemName) {
-          throw new Error("Item name is required for macOS Keychain");
-        }
-        const keychainProvider = new core.MacOSKeychainKeyProvider({
-          itemName: keychainItemName
-        });
-        const genOptions = { publicKeyPath };
-        if (props.force !== void 0) {
-          genOptions.force = props.force;
-        }
-        const result = await keychainProvider.generateKeyPair(genOptions);
-        onComplete({
-          provider: "macos-keychain",
-          publicKeyPath: result.publicKeyPath,
-          privateKeyRef: result.privateKeyRef,
-          storageDescription: result.storageDescription,
-          itemName: keychainItemName
-        });
-      } else {
-        const encryptedKeyPath = core.getDefaultYubiKeyEncryptedKeyPath();
-        const providerOptions = {
-          encryptedKeyPath,
-          slot: selectedYubiKeySlot
-        };
-        if (selectedYubiKeySerial !== void 0) {
-          providerOptions.serial = selectedYubiKeySerial;
-        }
-        const ykProvider = new core.YubiKeyProvider(providerOptions);
-        const genOptions = { publicKeyPath };
-        if (props.force !== void 0) {
-          genOptions.force = props.force;
-        }
-        const result = await ykProvider.generateKeyPair(genOptions);
-        const completionResult = {
-          provider: "yubikey",
-          publicKeyPath: result.publicKeyPath,
-          privateKeyRef: result.privateKeyRef,
-          storageDescription: result.storageDescription,
-          slot: selectedYubiKeySlot,
-          encryptedKeyPath
-        };
-        if (selectedYubiKeySerial !== void 0) {
-          completionResult.serial = selectedYubiKeySerial;
-        }
-        onComplete(completionResult);
-      }
-      setStep("done");
-    } catch (err) {
-      onError(err instanceof Error ? err : new Error("Key generation failed"));
-    } finally {
-      setEncryptionPassphrase(void 0);
-    }
-  };
-  if (step === "checking-providers") {
-    return /* @__PURE__ */ jsxRuntime.jsx(ink.Box, { flexDirection: "column", children: /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { flexDirection: "row", gap: 1, children: [
-      /* @__PURE__ */ jsxRuntime.jsx(ui.Spinner, {}),
-      /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { children: "Checking available key storage providers..." })
-    ] }) });
-  }
-  if (step === "select-provider") {
-    const options = [
-      {
-        label: `Local Filesystem (${core.getDefaultPrivateKeyPath()})`,
-        value: "filesystem"
-      }
-    ];
-    if (keychainAvailable) {
-      options.push({
-        label: "macOS Keychain",
-        value: "macos-keychain"
-      });
-    }
-    if (yubiKeyAvailable) {
-      options.push({
-        label: "YubiKey (hardware security key)",
-        value: "yubikey"
-      });
-    }
-    if (opAvailable) {
-      options.push({
-        label: "1Password (requires op CLI)",
-        value: "1password"
-      });
-    }
-    return /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { bold: true, children: "Where would you like to store your private key?" }),
-      /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { dimColor: true, children: "" }),
-      /* @__PURE__ */ jsxRuntime.jsx(ui.Select, { options, onChange: handleProviderSelect })
-    ] });
-  }
-  if (step === "select-filesystem-encryption") {
-    return /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { bold: true, children: "Would you like to encrypt your private key with a passphrase?" }),
-      /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { dimColor: true, children: "A passphrase adds extra security but must be entered each time you sign." }),
-      /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { dimColor: true, children: "" }),
-      /* @__PURE__ */ jsxRuntime.jsx(
-        ui.Select,
-        {
-          options: [
-            { label: "No encryption (key protected by file permissions only)", value: "none" },
-            { label: "Passphrase protection (AES-256 encryption)", value: "passphrase" }
-          ],
-          onChange: handleEncryptionMethodSelect
-        }
-      )
-    ] });
-  }
-  if (step === "enter-encryption-passphrase") {
-    return /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { bold: true, children: "Enter a passphrase to encrypt your private key:" }),
-      /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { dimColor: true, children: `(Minimum ${String(MIN_PASSPHRASE_LENGTH)} characters. You will need this passphrase each time you sign.)` }),
-      /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { dimColor: true, children: "" }),
-      /* @__PURE__ */ jsxRuntime.jsx(ui.PasswordInput, { onSubmit: handleEncryptionPassphrase })
-    ] });
-  }
-  if (step === "confirm-encryption-passphrase") {
-    return /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { bold: true, children: "Confirm your passphrase:" }),
-      /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { dimColor: true, children: "(Enter the same passphrase again to confirm.)" }),
-      /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { dimColor: true, children: "" }),
-      /* @__PURE__ */ jsxRuntime.jsx(ui.PasswordInput, { onSubmit: handleConfirmPassphrase })
-    ] });
-  }
-  if (step === "select-account") {
-    const options = accounts.map((account) => ({
-      label: account.name ? `${account.name} (${account.email})` : account.email,
-      value: account.user_uuid
-    }));
-    return /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { bold: true, children: "Select 1Password account:" }),
-      /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { dimColor: true, children: "" }),
-      /* @__PURE__ */ jsxRuntime.jsx(ui.Select, { options, onChange: handleAccountSelect })
-    ] });
-  }
-  if (step === "select-vault") {
-    if (vaults.length === 0) {
-      return /* @__PURE__ */ jsxRuntime.jsx(ink.Box, { flexDirection: "column", children: /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { flexDirection: "row", gap: 1, children: [
-        /* @__PURE__ */ jsxRuntime.jsx(ui.Spinner, {}),
-        /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { children: "Loading vaults..." })
-      ] }) });
-    }
-    const options = vaults.map((vault) => ({
-      label: vault.name,
-      value: vault.id
-    }));
-    return /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { bold: true, children: "Select vault for private key storage:" }),
-      /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { dimColor: true, children: "" }),
-      /* @__PURE__ */ jsxRuntime.jsx(ui.Select, { options, onChange: handleVaultSelect })
-    ] });
-  }
-  if (step === "enter-item-name") {
-    return /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { bold: true, children: "Enter name for the key item:" }),
-      /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { dimColor: true, children: "(This will be visible in your 1Password vault)" }),
-      /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { dimColor: true, children: "" }),
-      /* @__PURE__ */ jsxRuntime.jsx(ui.TextInput, { defaultValue: itemName, onSubmit: handleItemNameSubmit })
-    ] });
-  }
-  if (step === "enter-keychain-item-name") {
-    return /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { bold: true, children: "Enter name for the keychain item:" }),
-      /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { dimColor: true, children: "(This will be the service name in your macOS Keychain)" }),
-      /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { dimColor: true, children: "" }),
-      /* @__PURE__ */ jsxRuntime.jsx(ui.TextInput, { defaultValue: keychainItemName, onSubmit: handleKeychainItemNameSubmit })
-    ] });
-  }
-  if (step === "select-yubikey-device") {
-    const options = yubiKeyDevices.map((device) => ({
-      label: `${device.type} (Serial: ${device.serial})`,
-      value: device.serial
-    }));
-    return /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { bold: true, children: "Select YubiKey device:" }),
-      /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { dimColor: true, children: "" }),
-      /* @__PURE__ */ jsxRuntime.jsx(ui.Select, { options, onChange: handleYubiKeyDeviceSelect })
-    ] });
-  }
-  if (step === "select-yubikey-slot") {
-    const options = [];
-    if (slot2Configured) {
-      options.push({
-        label: "Slot 2 (recommended)",
-        value: "2"
-      });
-    }
-    if (slot1Configured) {
-      options.push({
-        label: "Slot 1",
-        value: "1"
-      });
-    }
-    return /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { bold: true, children: "Select YubiKey slot for challenge-response:" }),
-      /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { dimColor: true, children: "" }),
-      /* @__PURE__ */ jsxRuntime.jsx(ui.Select, { options, onChange: handleYubiKeySlotSelect })
-    ] });
-  }
-  if (step === "yubikey-offer-setup") {
-    return /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { bold: true, children: "Your YubiKey is not configured for challenge-response." }),
-      /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { dimColor: true, children: "" }),
-      /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { children: "Would you like to configure slot 2 for challenge-response now?" }),
-      /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { dimColor: true, children: "This will enable touch-to-sign functionality." }),
-      /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { dimColor: true, children: "" }),
-      /* @__PURE__ */ jsxRuntime.jsx(
-        ui.Select,
-        {
-          options: [
-            { label: "Yes, configure my YubiKey", value: "yes" },
-            { label: "No, cancel", value: "no" }
-          ],
-          onChange: handleYubiKeySetupConfirm
-        }
-      )
-    ] });
-  }
-  if (step === "yubikey-configuring") {
-    return /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { flexDirection: "row", gap: 1, children: [
-        /* @__PURE__ */ jsxRuntime.jsx(ui.Spinner, {}),
-        /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { children: "Configuring YubiKey slot 2 for challenge-response..." })
-      ] }),
-      /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { dimColor: true, children: "Touch your YubiKey when it flashes." })
-    ] });
-  }
-  if (step === "generating") {
-    return /* @__PURE__ */ jsxRuntime.jsx(ink.Box, { flexDirection: "column", children: /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { flexDirection: "row", gap: 1, children: [
-      /* @__PURE__ */ jsxRuntime.jsx(ui.Spinner, {}),
-      /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { children: "Generating RSA-2048 keypair..." })
-    ] }) });
-  }
-  return /* @__PURE__ */ jsxRuntime.jsx(ink.Box, {});
-}
-async function runKeygenInteractive(options) {
-  return new Promise((resolve2, reject) => {
-    const props = {
-      onComplete: (result) => {
-        unmount();
-        resolve2(result);
-      },
-      onCancel: () => {
-        unmount();
-        reject(new Error("Keygen cancelled"));
-      },
-      onError: (error2) => {
-        unmount();
-        reject(error2);
-      }
-    };
-    if (options.publicKeyPath !== void 0) {
-      props.publicKeyPath = options.publicKeyPath;
-    }
-    if (options.force !== void 0) {
-      props.force = options.force;
-    }
-    const { unmount } = ink.render(/* @__PURE__ */ jsxRuntime.jsx(KeygenInteractive, { ...props }));
-  });
-}
-
-// src/commands/keygen.ts
-var keygenCommand = new commander.Command("keygen").description("Generate a new RSA keypair for signing attestations").option("-o, --output <path>", "Public key output path").option("-p, --private <path>", "Private key output path (filesystem only)").option(
-  "--provider <type>",
-  "Key provider: filesystem, 1password, or macos-keychain (skips interactive)"
-).option("--vault <name>", "1Password vault name").option("--item-name <name>", "1Password/macOS Keychain item name").option("--account <email>", "1Password account").option("-f, --force", "Overwrite existing keys").option("--no-interactive", "Disable interactive mode").action(async (options) => {
-  await runKeygen(options);
-});
-async function runKeygen(options) {
-  try {
-    const useInteractive = options.interactive !== false && !options.provider;
-    if (useInteractive) {
-      const interactiveOptions = {};
-      if (options.output !== void 0) {
-        interactiveOptions.publicKeyPath = options.output;
-      }
-      if (options.force !== void 0) {
-        interactiveOptions.force = options.force;
-      }
-      const result = await runKeygenInteractive(interactiveOptions);
-      success("Keypair generated successfully!");
-      log("");
-      log("Private key stored in:");
-      log(`  ${result.storageDescription}`);
-      log("");
-      log("Public key (commit to repo):");
-      log(`  ${result.publicKeyPath}`);
-      log("");
-      if (result.provider === "1password") {
-        log("Add to your .attest-it/config.yaml:");
-        log("");
-        log("settings:");
-        log(`  publicKeyPath: ${result.publicKeyPath}`);
-        log("  keyProvider:");
-        log("    type: 1password");
-        log("    options:");
-        if (result.account) {
-          log(`      account: ${result.account}`);
-        }
-        log(`      vault: ${result.vault ?? ""}`);
-        log(`      itemName: ${result.itemName ?? ""}`);
-        log("");
-      } else if (result.provider === "macos-keychain") {
-        log("Add to your .attest-it/config.yaml:");
-        log("");
-        log("settings:");
-        log(`  publicKeyPath: ${result.publicKeyPath}`);
-        log("  keyProvider:");
-        log("    type: macos-keychain");
-        log("    options:");
-        log(`      itemName: ${result.itemName ?? ""}`);
-        log("");
-      }
-      log("Next steps:");
-      log(`  1. git add ${result.publicKeyPath}`);
-      if (result.provider === "1password" || result.provider === "macos-keychain") {
-        log("  2. Update .attest-it/config.yaml with keyProvider settings");
-      } else {
-        log("  2. Update .attest-it/config.yaml publicKeyPath if needed");
-      }
-      log("  3. attest-it run --suite <suite-name>");
-    } else {
-      await runNonInteractiveKeygen(options);
-    }
-  } catch (err) {
-    if (err instanceof Error) {
-      error(err.message);
-    } else {
-      error("Unknown error occurred");
-    }
-    process.exit(ExitCode.CONFIG_ERROR);
-  }
-}
-async function runNonInteractiveKeygen(options) {
-  log("Checking OpenSSL...");
-  const version = await core.checkOpenSSL();
-  info(`OpenSSL: ${version}`);
-  const publicPath = options.output ?? core.getDefaultPublicKeyPath();
-  if (options.provider === "1password") {
-    if (!options.vault || !options.itemName) {
-      throw new Error("--vault and --item-name are required for 1password provider");
-    }
-    const providerOptions = {
-      vault: options.vault,
-      itemName: options.itemName
-    };
-    if (options.account !== void 0) {
-      providerOptions.account = options.account;
-    }
-    const provider = new core.OnePasswordKeyProvider(providerOptions);
-    log(`Generating keypair with 1Password storage...`);
-    log(`Vault: ${options.vault}`);
-    log(`Item: ${options.itemName}`);
-    const genOptions = { publicKeyPath: publicPath };
-    if (options.force !== void 0) {
-      genOptions.force = options.force;
-    }
-    const result = await provider.generateKeyPair(genOptions);
-    success("Keypair generated successfully!");
-    log("");
-    log("Private key stored in:");
-    log(`  ${result.storageDescription}`);
-    log("");
-    log("Public key (commit to repo):");
-    log(`  ${result.publicKeyPath}`);
-  } else if (options.provider === "macos-keychain") {
-    if (!options.itemName) {
-      throw new Error("--item-name is required for macos-keychain provider");
-    }
-    const isAvailable = core.MacOSKeychainKeyProvider.isAvailable();
-    if (!isAvailable) {
-      throw new Error("macOS Keychain is not available on this platform");
-    }
-    const provider = new core.MacOSKeychainKeyProvider({
-      itemName: options.itemName
-    });
-    log(`Generating keypair with macOS Keychain storage...`);
-    log(`Item: ${options.itemName}`);
-    const genOptions = { publicKeyPath: publicPath };
-    if (options.force !== void 0) {
-      genOptions.force = options.force;
-    }
-    const result = await provider.generateKeyPair(genOptions);
-    success("Keypair generated successfully!");
-    log("");
-    log("Private key stored in:");
-    log(`  ${result.storageDescription}`);
-    log("");
-    log("Public key (commit to repo):");
-    log(`  ${result.publicKeyPath}`);
-  } else {
-    const privatePath = options.private ?? core.getDefaultPrivateKeyPath();
-    log(`Private key: ${privatePath}`);
-    log(`Public key: ${publicPath}`);
-    const privateExists = fs__namespace.existsSync(privatePath);
-    const publicExists = fs__namespace.existsSync(publicPath);
-    if ((privateExists || publicExists) && !options.force) {
-      if (privateExists) {
-        warn(`Private key already exists: ${privatePath}`);
-      }
-      if (publicExists) {
-        warn(`Public key already exists: ${publicPath}`);
-      }
-      const shouldOverwrite = await confirmAction({
-        message: "Overwrite existing keys?",
-        default: false
-      });
-      if (!shouldOverwrite) {
-        error("Keygen cancelled");
-        process.exit(ExitCode.CANCELLED);
-      }
-    }
-    log("\nGenerating RSA-2048 keypair...");
-    const result = await core.generateKeyPair({
-      privatePath,
-      publicPath,
-      force: true
-    });
-    await core.setKeyPermissions(result.privatePath);
-    success("Keypair generated successfully!");
-    log("");
-    log("Private key (KEEP SECRET):");
-    log(`  ${result.privatePath}`);
-    log("");
-    log("Public key (commit to repo):");
-    log(`  ${result.publicPath}`);
-  }
-  log("");
-  info("Important: Back up your private key securely!");
-  log("");
-  log("Next steps:");
-  log(`  1. git add ${publicPath}`);
-  log("  2. Update .attest-it/config.yaml publicKeyPath if needed");
-  log("  3. attest-it run --suite <suite-name>");
-}
 var pruneCommand = new commander.Command("prune").description("Remove stale attestations").option("-n, --dry-run", "Show what would be removed without removing").option("-k, --keep-days <n>", "Keep attestations newer than n days", "30").action(async (options) => {
   await runPrune(options);
 });
@@ -2619,7 +1981,7 @@ async function runSeal(gates, options) {
     const localConfig = core.loadLocalConfigSync();
     if (!localConfig) {
       error("No local identity configuration found");
-      error('Run "attest-it keygen" first to set up your identity');
+      error('Run "attest-it identity create" first to set up your identity');
       process.exit(ExitCode.CONFIG_ERROR);
     }
     const identity = core.getActiveIdentity(localConfig);
@@ -2716,8 +2078,8 @@ async function processSingleGate(gateId, config, identity, identitySlug, sealsFi
   const keyProvider = createKeyProviderFromIdentity2(identity);
   const keyRef = getKeyRefFromIdentity2(identity);
   const keyResult = await keyProvider.getPrivateKey(keyRef);
-  const fs4 = await import('fs/promises');
-  const privateKeyPem = await fs4.readFile(keyResult.keyPath, "utf8");
+  const fs3 = await import('fs/promises');
+  const privateKeyPem = await fs3.readFile(keyResult.keyPath, "utf8");
   await keyResult.cleanup();
   const seal = core.createSeal({
     gateId,
@@ -2938,10 +2300,19 @@ async function runCreate() {
       default: ""
     });
     info("Checking available key storage providers...");
+    info(
+      "You may see authentication prompts from 1Password, macOS Keychain, or other security tools."
+    );
     const opAvailable = await core.OnePasswordKeyProvider.isInstalled();
+    verbose(`  1Password CLI (op): ${opAvailable ? "found" : "not found"}`);
     const keychainAvailable = core.MacOSKeychainKeyProvider.isAvailable();
+    verbose(`  macOS Keychain: ${keychainAvailable ? "available" : "not available (not macOS)"}`);
     const yubikeyInstalled = await core.YubiKeyProvider.isInstalled();
+    verbose(`  YubiKey CLI (ykman): ${yubikeyInstalled ? "found" : "not found"}`);
     const yubikeyConnected = yubikeyInstalled ? await core.YubiKeyProvider.isConnected() : false;
+    if (yubikeyInstalled) {
+      verbose(`  YubiKey device: ${yubikeyConnected ? "connected" : "not connected"}`);
+    }
     const configDir = core.getAttestItConfigDir();
     const storageChoices = [
       { name: `File system (${path.join(configDir, "keys")})`, value: "file" }
@@ -2955,24 +2326,24 @@ async function runCreate() {
     if (yubikeyInstalled) {
       const yubikeyLabel = yubikeyConnected ? "YubiKey (encrypted with challenge-response)" : "YubiKey (not connected - insert YubiKey first)";
       storageChoices.push({ name: yubikeyLabel, value: "yubikey" });
+    } else {
+      storageChoices.push({
+        name: theme3.muted("YubiKey (install ykman CLI to enable)"),
+        value: "yubikey-disabled",
+        // @ts-expect-error -- @inquirer/prompts supports disabled property but types may not reflect it
+        disabled: true
+      });
     }
     const keyStorageType = await prompts.select({
       message: "Where should the private key be stored?",
       choices: storageChoices
     });
-    log("");
-    log("Generating Ed25519 keypair...");
-    const keyPair = core.generateEd25519KeyPair();
-    let privateKeyRef;
-    let keyStorageDescription;
+    let storageConfig;
     switch (keyStorageType) {
       case "file": {
         const keysDir = path.join(core.getAttestItConfigDir(), "keys");
-        await promises.mkdir(keysDir, { recursive: true });
         const keyPath = path.join(keysDir, `${slug}.pem`);
-        await promises.writeFile(keyPath, keyPair.privateKey, { mode: 384 });
-        privateKeyRef = { type: "file", path: keyPath };
-        keyStorageDescription = keyPath;
+        storageConfig = { type: "file", keyPath };
         break;
       }
       case "keychain": {
@@ -2980,6 +2351,9 @@ async function runCreate() {
           error("macOS Keychain is not available on this system");
           process.exit(ExitCode.CONFIG_ERROR);
         }
+        log("");
+        info("Accessing macOS Keychain to list available keychains...");
+        info("You may be prompted to allow access or enter your password.");
         const keychains = await core.MacOSKeychainKeyProvider.listKeychains();
         if (keychains.length === 0) {
           throw new Error("No keychains found on this system");
@@ -3015,38 +2389,15 @@ async function runCreate() {
             return true;
           }
         });
-        const { execFile } = await import('child_process');
-        const { promisify } = await import('util');
-        const execFileAsync = promisify(execFile);
-        const encodedKey = Buffer.from(keyPair.privateKey).toString("base64");
-        try {
-          const addArgs = [
-            "add-generic-password",
-            "-a",
-            "attest-it",
-            "-s",
-            keychainItemName,
-            "-w",
-            encodedKey,
-            "-U",
-            selectedKeychain.path
-          ];
-          await execFileAsync("security", addArgs);
-        } catch (err) {
-          throw new Error(
-            `Failed to store key in macOS Keychain: ${err instanceof Error ? err.message : String(err)}`
-          );
-        }
-        privateKeyRef = {
-          type: "keychain",
-          service: keychainItemName,
-          account: "attest-it",
-          keychain: selectedKeychain.path
-        };
-        keyStorageDescription = `macOS Keychain: ${selectedKeychain.name}/${keychainItemName}`;
+        storageConfig = { type: "keychain", selectedKeychain, keychainItemName };
         break;
       }
       case "1password": {
+        log("");
+        info("Accessing 1Password to list your accounts and vaults...");
+        info(
+          "You may see biometric prompts or be asked to unlock 1Password for each configured account."
+        );
         const accounts = await core.OnePasswordKeyProvider.listAccounts();
         if (accounts.length === 0) {
           throw new Error(
@@ -3067,7 +2418,7 @@ async function runCreate() {
                 "--format=json"
               ]);
               const details = JSON.parse(stdout);
-              const name2 = details !== null && typeof details === "object" && "name" in details && typeof details.name === "string" ? details.name : acc.url;
+              const name2 = details !== null && typeof details === "object" && "name" in details && typeof details.name === "string" ? details.name : "[Could not read account name]";
               return {
                 url: acc.url,
                 email: acc.email,
@@ -3077,7 +2428,7 @@ async function runCreate() {
               return {
                 url: acc.url,
                 email: acc.email,
-                name: acc.url
+                name: "[Could not read account name]"
               };
             }
           })
@@ -3119,43 +2470,21 @@ async function runCreate() {
             return true;
           }
         });
-        const { tmpdir } = await import('os');
-        const tempDir = path.join(tmpdir(), `attest-it-${String(Date.now())}`);
-        await promises.mkdir(tempDir, { recursive: true });
-        const tempPrivatePath = path.join(tempDir, "private.pem");
-        try {
-          await promises.writeFile(tempPrivatePath, keyPair.privateKey, { mode: 384 });
-          const { execFile: execFile2 } = await import('child_process');
-          const { promisify: promisify2 } = await import('util');
-          const execFileAsync2 = promisify2(execFile2);
-          const opArgs = [
-            "document",
-            "create",
-            tempPrivatePath,
-            "--title",
-            item,
-            "--vault",
-            selectedVault
-          ];
-          if (selectedAccount) {
-            opArgs.push("--account", selectedAccount);
-          }
-          await execFileAsync2("op", opArgs);
-        } finally {
-          const { rm } = await import('fs/promises');
-          await rm(tempDir, { recursive: true, force: true }).catch(() => {
-          });
-        }
-        privateKeyRef = {
+        const selectedAccountDetails = accountDetails.find((acc) => acc.url === selectedAccount);
+        const accountDisplayName = selectedAccountDetails?.name ?? selectedAccount;
+        storageConfig = {
           type: "1password",
-          vault: selectedVault,
-          item,
-          ...selectedAccount && { account: selectedAccount }
+          selectedAccount,
+          accountDisplayName,
+          selectedVault,
+          item
         };
-        keyStorageDescription = `1Password (${selectedVault}/${item})`;
         break;
       }
       case "yubikey": {
+        log("");
+        info("Accessing YubiKey to detect connected devices...");
+        info("Your private key will be encrypted using HMAC challenge-response from the YubiKey.");
         if (!await core.YubiKeyProvider.isConnected()) {
           error("No YubiKey detected. Please insert your YubiKey and try again.");
           process.exit(ExitCode.CONFIG_ERROR);
@@ -3207,25 +2536,115 @@ async function runCreate() {
           }
         });
         const keysDir = path.join(core.getAttestItConfigDir(), "keys");
-        await promises.mkdir(keysDir, { recursive: true });
         const encryptedKeyPath = path.join(keysDir, encryptedKeyName);
+        storageConfig = { type: "yubikey", selectedSerial, slot, encryptedKeyPath };
+        break;
+      }
+      default:
+        throw new Error(`Unknown key storage type: ${keyStorageType}`);
+    }
+    log("");
+    log("Generating Ed25519 keypair...");
+    const keyPair = core.generateEd25519KeyPair();
+    let privateKeyRef;
+    let keyStorageDescription;
+    switch (storageConfig.type) {
+      case "file": {
+        log("");
+        info("Creating private key file on disk...");
+        const keysDir = path.join(core.getAttestItConfigDir(), "keys");
+        await promises.mkdir(keysDir, { recursive: true });
+        await promises.writeFile(storageConfig.keyPath, keyPair.privateKey, { mode: 384 });
+        privateKeyRef = { type: "file", path: storageConfig.keyPath };
+        keyStorageDescription = storageConfig.keyPath;
+        break;
+      }
+      case "keychain": {
+        const { execFile } = await import('child_process');
+        const { promisify } = await import('util');
+        const execFileAsync = promisify(execFile);
+        const encodedKey = Buffer.from(keyPair.privateKey).toString("base64");
+        try {
+          const addArgs = [
+            "add-generic-password",
+            "-a",
+            "attest-it",
+            "-s",
+            storageConfig.keychainItemName,
+            "-w",
+            encodedKey,
+            "-U",
+            storageConfig.selectedKeychain.path
+          ];
+          await execFileAsync("security", addArgs);
+        } catch (err) {
+          throw new Error(
+            `Failed to store key in macOS Keychain: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+        privateKeyRef = {
+          type: "keychain",
+          service: storageConfig.keychainItemName,
+          account: "attest-it",
+          keychain: storageConfig.selectedKeychain.path
+        };
+        keyStorageDescription = `macOS Keychain: ${storageConfig.selectedKeychain.name}/${storageConfig.keychainItemName}`;
+        break;
+      }
+      case "1password": {
+        const { tmpdir } = await import('os');
+        const tempDir = path.join(tmpdir(), `attest-it-${String(Date.now())}`);
+        await promises.mkdir(tempDir, { recursive: true });
+        const tempPrivatePath = path.join(tempDir, "private.pem");
+        try {
+          await promises.writeFile(tempPrivatePath, keyPair.privateKey, { mode: 384 });
+          const { execFile } = await import('child_process');
+          const { promisify } = await import('util');
+          const execFileAsync = promisify(execFile);
+          const opArgs = [
+            "document",
+            "create",
+            tempPrivatePath,
+            "--title",
+            storageConfig.item,
+            "--vault",
+            storageConfig.selectedVault,
+            "--account",
+            storageConfig.selectedAccount
+          ];
+          await execFileAsync("op", opArgs);
+        } finally {
+          const { rm } = await import('fs/promises');
+          await rm(tempDir, { recursive: true, force: true }).catch(() => {
+          });
+        }
+        privateKeyRef = {
+          type: "1password",
+          vault: storageConfig.selectedVault,
+          item: storageConfig.item,
+          account: storageConfig.selectedAccount
+        };
+        keyStorageDescription = `1Password (${storageConfig.accountDisplayName}/${storageConfig.selectedVault}/${storageConfig.item})`;
+        break;
+      }
+      case "yubikey": {
+        const keysDir = path.join(core.getAttestItConfigDir(), "keys");
+        await promises.mkdir(keysDir, { recursive: true });
         const result = await core.YubiKeyProvider.encryptPrivateKey({
           privateKey: keyPair.privateKey,
-          encryptedKeyPath,
-          slot,
-          serial: selectedSerial
+          encryptedKeyPath: storageConfig.encryptedKeyPath,
+          slot: storageConfig.slot,
+          serial: storageConfig.selectedSerial
         });
         privateKeyRef = {
           type: "yubikey",
           encryptedKeyPath: result.encryptedKeyPath,
-          slot,
-          serial: selectedSerial
+          slot: storageConfig.slot,
+          serial: storageConfig.selectedSerial
         };
         keyStorageDescription = result.storageDescription;
         break;
       }
-      default:
-        throw new Error(`Unknown key storage type: ${keyStorageType}`);
     }
     const identity = {
       name,
@@ -3269,9 +2688,9 @@ async function runCreate() {
     log("");
     log(theme3.blue.bold()("Public key saved to:"));
     log(`  ${publicKeyResult.homePath}`);
-    if (publicKeyResult.projectPath) {
-      log(`  ${publicKeyResult.projectPath}`);
-    }
+    log("");
+    log("To add yourself to a project, run:");
+    log(theme3.blue("  attest-it team join"));
     log("");
     if (!existingConfig) {
       success(`Set as active identity`);
@@ -3392,155 +2811,6 @@ async function runShow(slug) {
     process.exit(ExitCode.CONFIG_ERROR);
   }
 }
-var editCommand = new commander.Command("edit").description("Edit identity or rotate keypair").argument("<slug>", "Identity slug to edit").action(async (slug) => {
-  await runEdit(slug);
-});
-async function runEdit(slug) {
-  try {
-    const config = await core.loadLocalConfig();
-    if (!config) {
-      error("No identities configured");
-      process.exit(ExitCode.CONFIG_ERROR);
-    }
-    const identity = config.identities[slug];
-    if (!identity) {
-      error(`Identity "${slug}" not found`);
-      process.exit(ExitCode.CONFIG_ERROR);
-    }
-    const theme3 = getTheme2();
-    log("");
-    log(theme3.blue.bold()(`Edit Identity: ${slug}`));
-    log("");
-    const name = await prompts.input({
-      message: "Display name:",
-      default: identity.name,
-      validate: (value) => {
-        if (!value || value.trim().length === 0) {
-          return "Name cannot be empty";
-        }
-        return true;
-      }
-    });
-    const email = await prompts.input({
-      message: "Email (optional):",
-      default: identity.email ?? ""
-    });
-    const github = await prompts.input({
-      message: "GitHub username (optional):",
-      default: identity.github ?? ""
-    });
-    const rotateKey = await prompts.confirm({
-      message: "Rotate keypair (generate new keys)?",
-      default: false
-    });
-    let publicKey = identity.publicKey;
-    const privateKeyRef = identity.privateKey;
-    if (rotateKey) {
-      log("");
-      log("Generating new Ed25519 keypair...");
-      const keyPair = core.generateEd25519KeyPair();
-      publicKey = keyPair.publicKey;
-      switch (identity.privateKey.type) {
-        case "file": {
-          await promises.writeFile(identity.privateKey.path, keyPair.privateKey, { mode: 384 });
-          log(`  Updated private key at: ${identity.privateKey.path}`);
-          break;
-        }
-        case "keychain": {
-          const { execFile } = await import('child_process');
-          const { promisify } = await import('util');
-          const execFileAsync = promisify(execFile);
-          const encodedKey = Buffer.from(keyPair.privateKey).toString("base64");
-          try {
-            await execFileAsync("security", [
-              "delete-generic-password",
-              "-s",
-              identity.privateKey.service,
-              "-a",
-              identity.privateKey.account
-            ]);
-            await execFileAsync("security", [
-              "add-generic-password",
-              "-s",
-              identity.privateKey.service,
-              "-a",
-              identity.privateKey.account,
-              "-w",
-              encodedKey,
-              "-U"
-            ]);
-            log(`  Updated private key in macOS Keychain`);
-          } catch (err) {
-            throw new Error(
-              `Failed to update key in macOS Keychain: ${err instanceof Error ? err.message : String(err)}`
-            );
-          }
-          break;
-        }
-        case "1password": {
-          const { execFile } = await import('child_process');
-          const { promisify } = await import('util');
-          const execFileAsync = promisify(execFile);
-          try {
-            const opArgs = [
-              "item",
-              "edit",
-              identity.privateKey.item,
-              "--vault",
-              identity.privateKey.vault,
-              `privateKey[password]=${keyPair.privateKey}`
-            ];
-            if (identity.privateKey.account) {
-              opArgs.push("--account", identity.privateKey.account);
-            }
-            await execFileAsync("op", opArgs);
-            log(`  Updated private key in 1Password`);
-          } catch (err) {
-            throw new Error(
-              `Failed to update key in 1Password: ${err instanceof Error ? err.message : String(err)}`
-            );
-          }
-          break;
-        }
-      }
-    }
-    const updatedIdentity = {
-      name,
-      publicKey,
-      privateKey: privateKeyRef,
-      ...email && { email },
-      ...github && { github }
-    };
-    const newConfig = {
-      ...config,
-      identities: {
-        ...config.identities,
-        [slug]: updatedIdentity
-      }
-    };
-    await core.saveLocalConfig(newConfig);
-    log("");
-    success("Identity updated successfully");
-    log("");
-    if (rotateKey) {
-      log("  New Public Key: " + publicKey.slice(0, 32) + "...");
-      log("");
-      log(
-        theme3.yellow(
-          "  Warning: If this identity is used in team configurations,\n  you must update those configurations with the new public key."
-        )
-      );
-      log("");
-    }
-  } catch (err) {
-    if (err instanceof Error) {
-      error(err.message);
-    } else {
-      error("Unknown error occurred");
-    }
-    process.exit(ExitCode.CONFIG_ERROR);
-  }
-}
 
 // src/utils/format-key-location.ts
 function formatKeyLocation(privateKey) {
@@ -3759,7 +3029,7 @@ async function runExport(slug) {
 }
 
 // src/commands/identity/index.ts
-var identityCommand = new commander.Command("identity").description("Manage local identities and keypairs").addCommand(listCommand).addCommand(createCommand).addCommand(useCommand).addCommand(showCommand).addCommand(editCommand).addCommand(removeCommand).addCommand(exportCommand);
+var identityCommand = new commander.Command("identity").description("Manage local identities and keypairs").addCommand(listCommand).addCommand(createCommand).addCommand(useCommand).addCommand(showCommand).addCommand(removeCommand).addCommand(exportCommand);
 var whoamiCommand = new commander.Command("whoami").description("Show the current active identity").action(async () => {
   await runWhoami();
 });
@@ -3860,6 +3130,49 @@ async function runList2() {
     process.exit(ExitCode.CONFIG_ERROR);
   }
 }
+async function promptForGateAuthorization(gates) {
+  if (!gates || Object.keys(gates).length === 0) {
+    return [];
+  }
+  const gateChoices = Object.entries(gates).map(([gateId, gate]) => ({
+    name: `${gateId} - ${gate.name}`,
+    value: gateId
+  }));
+  const authorizedGates = await prompts.checkbox({
+    message: "Select gates to authorize (use space to select):",
+    choices: gateChoices
+  });
+  return authorizedGates;
+}
+function addTeamMemberToConfig(config, memberSlug, memberData, authorizedGates) {
+  const existingTeam = config.team ?? {};
+  const updatedConfig = {
+    ...config,
+    team: {
+      ...existingTeam,
+      [memberSlug]: {
+        name: memberData.name,
+        publicKey: memberData.publicKey,
+        publicKeyAlgorithm: memberData.publicKeyAlgorithm ?? "ed25519",
+        ...memberData.email ? { email: memberData.email } : {},
+        ...memberData.github ? { github: memberData.github } : {}
+      }
+    }
+  };
+  if (authorizedGates.length > 0 && updatedConfig.gates) {
+    for (const gateId of authorizedGates) {
+      const gate = updatedConfig.gates[gateId];
+      if (gate) {
+        if (!gate.authorizedSigners.includes(memberSlug)) {
+          gate.authorizedSigners.push(memberSlug);
+        }
+      }
+    }
+  }
+  return updatedConfig;
+}
+
+// src/commands/team/add.ts
 var addCommand = new commander.Command("add").description("Add a new team member").action(async () => {
   await runAdd();
 });
@@ -3931,45 +3244,22 @@ async function runAdd() {
       message: "Public key:",
       validate: validatePublicKey
     });
-    let authorizedGates = [];
-    if (attestItConfig.gates && Object.keys(attestItConfig.gates).length > 0) {
-      log("");
-      const gateChoices = Object.entries(attestItConfig.gates).map(([gateId, gate]) => ({
-        name: `${gateId} - ${gate.name}`,
-        value: gateId
-      }));
-      authorizedGates = await prompts.checkbox({
-        message: "Select gates to authorize (use space to select):",
-        choices: gateChoices
-      });
-    }
-    const teamMember = {
+    log("");
+    const authorizedGates = await promptForGateAuthorization(attestItConfig.gates);
+    const memberData = {
       name,
-      publicKey: publicKey.trim()
+      publicKey: publicKey.trim(),
+      publicKeyAlgorithm: "ed25519"
     };
-    if (email && email.trim().length > 0) {
-      teamMember.email = email.trim();
+    const trimmedEmail = email.trim();
+    const trimmedGithub = github.trim();
+    if (trimmedEmail && trimmedEmail.length > 0) {
+      memberData.email = trimmedEmail;
     }
-    if (github && github.trim().length > 0) {
-      teamMember.github = github.trim();
-    }
-    const updatedConfig = {
-      ...config,
-      team: {
-        ...existingTeam,
-        [slug]: teamMember
-      }
-    };
-    if (authorizedGates.length > 0 && updatedConfig.gates) {
-      for (const gateId of authorizedGates) {
-        const gate = updatedConfig.gates[gateId];
-        if (gate) {
-          if (!gate.authorizedSigners.includes(slug)) {
-            gate.authorizedSigners.push(slug);
-          }
-        }
-      }
+    if (trimmedGithub && trimmedGithub.length > 0) {
+      memberData.github = trimmedGithub;
     }
+    const updatedConfig = addTeamMemberToConfig(config, slug, memberData, authorizedGates);
     const configPath = core.findConfigPath();
     if (!configPath) {
       error("Configuration file not found");
@@ -3992,127 +3282,73 @@ async function runAdd() {
     process.exit(ExitCode.CONFIG_ERROR);
   }
 }
-var editCommand2 = new commander.Command("edit").description("Edit a team member").argument("<slug>", "Team member slug to edit").action(async (slug) => {
-  await runEdit2(slug);
+var joinCommand = new commander.Command("join").description("Add yourself to the project team using your active identity").action(async () => {
+  await runJoin();
 });
-function validatePublicKey2(value) {
-  if (!value || value.trim().length === 0) {
-    return "Public key cannot be empty";
-  }
-  const base64Regex = /^[A-Za-z0-9+/]+=*$/;
-  if (!base64Regex.test(value)) {
-    return "Public key must be valid Base64";
-  }
-  if (value.length !== 44) {
-    return "Public key must be 44 characters (32 bytes in Base64)";
-  }
-  try {
-    const decoded = Buffer.from(value, "base64");
-    if (decoded.length !== 32) {
-      return "Public key must decode to 32 bytes";
-    }
-  } catch {
-    return "Invalid Base64 encoding";
-  }
-  return true;
-}
-async function runEdit2(slug) {
+async function runJoin() {
   try {
     const theme3 = getTheme2();
-    const config = await core.loadConfig();
-    const attestItConfig = core.toAttestItConfig(config);
-    const existingMember = attestItConfig.team?.[slug];
-    if (!existingMember) {
-      error(`Team member "${slug}" not found`);
-      process.exit(ExitCode.CONFIG_ERROR);
-    }
     log("");
-    log(theme3.blue.bold()(`Edit Team Member: ${slug}`));
+    log(theme3.blue.bold()("Join Project Team"));
     log("");
-    log(theme3.muted("Leave blank to keep current value"));
+    const localConfig = await core.loadLocalConfig();
+    if (!localConfig) {
+      error('No identity found. Run "attest-it identity create" first.');
+      process.exit(ExitCode.CONFIG_ERROR);
+    }
+    const activeIdentity = core.getActiveIdentity(localConfig);
+    if (!activeIdentity) {
+      error('No active identity. Run "attest-it identity use <slug>" to select one.');
+      process.exit(ExitCode.CONFIG_ERROR);
+    }
+    const activeSlug = localConfig.activeIdentity;
+    info(`Using identity: ${activeSlug}`);
+    log(`  Name: ${activeIdentity.name}`);
+    log(`  Public Key: ${activeIdentity.publicKey.slice(0, 32)}...`);
     log("");
-    const name = await prompts.input({
-      message: "Display name:",
-      default: existingMember.name,
-      validate: (value) => {
-        if (!value || value.trim().length === 0) {
-          return "Name cannot be empty";
-        }
-        return true;
-      }
-    });
-    const email = await prompts.input({
-      message: "Email (optional):",
-      default: existingMember.email ?? ""
-    });
-    const github = await prompts.input({
-      message: "GitHub username (optional):",
-      default: existingMember.github ?? ""
-    });
-    const updateKey = await prompts.confirm({
-      message: "Update public key?",
-      default: false
-    });
-    let publicKey = existingMember.publicKey;
-    if (updateKey) {
-      log("");
-      log("Paste the new public key:");
-      publicKey = await prompts.input({
-        message: "Public key:",
-        default: existingMember.publicKey,
-        validate: validatePublicKey2
-      });
+    const config = await core.loadConfig();
+    const attestItConfig = core.toAttestItConfig(config);
+    const existingTeam = attestItConfig.team ?? {};
+    const existingMemberWithKey = Object.entries(existingTeam).find(
+      ([, member]) => member.publicKey === activeIdentity.publicKey
+    );
+    if (existingMemberWithKey) {
+      error(`You're already a team member as "${existingMemberWithKey[0]}"`);
+      process.exit(ExitCode.CONFIG_ERROR);
     }
-    const currentGates = [];
-    if (attestItConfig.gates) {
-      for (const [gateId, gate] of Object.entries(attestItConfig.gates)) {
-        if (gate.authorizedSigners.includes(slug)) {
-          currentGates.push(gateId);
+    let slug = activeSlug;
+    if (existingTeam[slug]) {
+      log(`Slug "${slug}" is already taken by another team member.`);
+      slug = await prompts.input({
+        message: "Choose a different slug:",
+        validate: (value) => {
+          if (!value || value.trim().length === 0) {
+            return "Slug cannot be empty";
+          }
+          if (!/^[a-z0-9-]+$/.test(value)) {
+            return "Slug must contain only lowercase letters, numbers, and hyphens";
+          }
+          if (existingTeam[value]) {
+            return `Slug "${value}" is already taken`;
+          }
+          return true;
         }
-      }
-    }
-    let selectedGates = currentGates;
-    if (attestItConfig.gates && Object.keys(attestItConfig.gates).length > 0) {
-      log("");
-      const gateChoices = Object.entries(attestItConfig.gates).map(([gateId, gate]) => ({
-        name: `${gateId} - ${gate.name}`,
-        value: gateId,
-        checked: currentGates.includes(gateId)
-      }));
-      selectedGates = await prompts.checkbox({
-        message: "Select gates to authorize (use space to select):",
-        choices: gateChoices
       });
     }
-    const updatedMember = {
-      name: name.trim(),
-      publicKey: publicKey.trim()
+    log("");
+    const authorizedGates = await promptForGateAuthorization(attestItConfig.gates);
+    const memberData = {
+      name: activeIdentity.name,
+      publicKey: activeIdentity.publicKey,
+      publicKeyAlgorithm: "ed25519"
     };
-    if (email && email.trim().length > 0) {
-      updatedMember.email = email.trim();
-    }
-    if (github && github.trim().length > 0) {
-      updatedMember.github = github.trim();
+    if (activeIdentity.email) {
+      memberData.email = activeIdentity.email;
     }
-    const updatedConfig = {
-      ...config,
-      team: {
-        ...attestItConfig.team,
-        [slug]: updatedMember
-      }
-    };
-    if (updatedConfig.gates) {
-      for (const [gateId, gate] of Object.entries(updatedConfig.gates)) {
-        if (currentGates.includes(gateId) && !selectedGates.includes(gateId)) {
-          gate.authorizedSigners = gate.authorizedSigners.filter((s) => s !== slug);
-        }
-        if (!currentGates.includes(gateId) && selectedGates.includes(gateId)) {
-          if (!gate.authorizedSigners.includes(slug)) {
-            gate.authorizedSigners.push(slug);
-          }
-        }
-      }
+    if (activeIdentity.github) {
+      memberData.github = activeIdentity.github;
     }
+    const updatedConfig = addTeamMemberToConfig(config, slug, memberData, authorizedGates);
     const configPath = core.findConfigPath();
     if (!configPath) {
       error("Configuration file not found");
@@ -4121,11 +3357,9 @@ async function runEdit2(slug) {
     const yamlContent = yaml.stringify(updatedConfig);
     await promises.writeFile(configPath, yamlContent, "utf8");
     log("");
-    success(`Team member "${slug}" updated successfully`);
-    if (selectedGates.length > 0) {
-      log(`Authorized for gates: ${selectedGates.join(", ")}`);
-    } else {
-      log("Not authorized for any gates");
+    success(`Team member "${slug}" added successfully`);
+    if (authorizedGates.length > 0) {
+      log(`Authorized for gates: ${authorizedGates.join(", ")}`);
     }
     log("");
   } catch (err) {
@@ -4240,7 +3474,7 @@ async function runRemove2(slug, options) {
 }
 
 // src/commands/team/index.ts
-var teamCommand = new commander.Command("team").description("Manage team members and authorizations").addCommand(listCommand2).addCommand(addCommand).addCommand(editCommand2).addCommand(removeCommand2);
+var teamCommand = new commander.Command("team").description("Manage team members and authorizations").addCommand(listCommand2).addCommand(addCommand).addCommand(joinCommand).addCommand(removeCommand2);
 var PROGRAM_NAME2 = "attest-it";
 var PROGRAM_ALIAS2 = "attest";
 var PROGRAM_NAMES = [PROGRAM_NAME2, PROGRAM_ALIAS2];
@@ -4261,7 +3495,6 @@ async function getCompletions(env) {
     { name: "run", description: "Run test suites interactively" },
     { name: "verify", description: "Verify all seals are valid" },
     { name: "seal", description: "Create a seal for a gate" },
-    { name: "keygen", description: "Generate a new keypair" },
     { name: "prune", description: "Remove stale attestations" },
     { name: "identity", description: "Manage identities" },
     { name: "team", description: "Manage team members" },
@@ -4366,7 +3599,6 @@ async function getCompletions(env) {
     "run",
     "verify",
     "seal",
-    "keygen",
     "prune",
     "identity",
     "team",
@@ -4501,43 +3733,12 @@ function createCompletionServerCommand() {
     }
   });
 }
-function hasVersion(data) {
-  return typeof data === "object" && data !== null && "version" in data && // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-  typeof data.version === "string";
-}
-var cachedVersion;
-function getPackageVersion() {
-  if (cachedVersion !== void 0) {
-    return cachedVersion;
-  }
-  const __filename = url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
-  const __dirname = path.dirname(__filename);
-  const possiblePaths = [path.join(__dirname, "../package.json"), path.join(__dirname, "../../package.json")];
-  for (const packageJsonPath of possiblePaths) {
-    try {
-      const content = fs.readFileSync(packageJsonPath, "utf-8");
-      const packageJsonData = JSON.parse(content);
-      if (!hasVersion(packageJsonData)) {
-        throw new Error(`Invalid package.json at ${packageJsonPath}: missing version field`);
-      }
-      cachedVersion = packageJsonData.version;
-      return cachedVersion;
-    } catch (error2) {
-      if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT") {
-        continue;
-      }
-      throw error2;
-    }
-  }
-  throw new Error("Could not find package.json");
-}
 var program = new commander.Command();
 program.name("attest-it").description("Human-gated test attestation system").option("-c, --config <path>", "Path to config file").option("-v, --verbose", "Verbose output").option("-q, --quiet", "Minimal output");
 program.option("-V, --version", "output the version number");
 program.addCommand(initCommand);
 program.addCommand(statusCommand);
 program.addCommand(runCommand);
-program.addCommand(keygenCommand);
 program.addCommand(pruneCommand);
 program.addCommand(verifyCommand);
 program.addCommand(sealCommand);