@hardkas/cli 0.2.2-alpha.1 → 0.4.0-alpha

package/dist/accounts-keystore-runners-QYSNZMZV.js

@@ -0,0 +1,155 @@
+import {
+  acquirePassword,
+  acquirePrivateKey
+} from "./chunk-ZM2NBOAE.js";
+import {
+  UI
+} from "./chunk-K7XPWWIO.js";
+
+// src/runners/accounts-keystore-runners.ts
+import fs from "fs";
+import path from "path";
+import { KeystoreManager, loadOrCreateRealAccountStore, saveRealAccountStore, importRealDevAccount } from "@hardkas/accounts";
+async function runAccountsKeystoreImport(options) {
+  const name = options.name || "default";
+  const address = options.address;
+  if (options.unsafePlaintext) {
+    UI.warning("LEGACY MODE: Storing private keys in plaintext is unsafe and discouraged.");
+    if (!options.yes) {
+      const confirmed = await UI.confirm("Are you sure you want to store this key in plaintext?");
+      if (!confirmed) throw new Error("Import cancelled by user.");
+    }
+  } else {
+    UI.info("HardKAS: Encrypted keystore is for local developer workflows, not institutional custody.");
+    UI.info("Do not import mainnet keys unless you fully understand the risks.");
+  }
+  if (!address) {
+    throw new Error("Address is required for import.");
+  }
+  let privateKeyUsedAsArg = false;
+  let finalKey;
+  if (options.privateKeyStdin || options.privateKeyEnv) {
+    finalKey = await acquirePrivateKey({
+      stdin: !!options.privateKeyStdin,
+      env: options.privateKeyEnv,
+      message: `Enter private key for account '${name}':`
+    });
+  } else if (options.privateKey) {
+    finalKey = options.privateKey;
+    privateKeyUsedAsArg = true;
+  } else {
+    finalKey = await acquirePrivateKey({
+      message: `Enter private key for account '${name}':`
+    });
+  }
+  if (privateKeyUsedAsArg) {
+    const warningMsg = "--private-key may be recorded in shell history, process lists, CI logs, or terminal scrollback.";
+    const suggestion = "Use --private-key-stdin or --private-key-env instead.";
+    if (!options.json) {
+      UI.securityWarning("PRIVATE_KEY_ARG_DEPRECATED", warningMsg, suggestion);
+    }
+  }
+  if (!finalKey) {
+    throw new Error("Private key is required for import.");
+  }
+  let keystoreRef;
+  if (!options.unsafePlaintext) {
+    const password = await acquirePassword({
+      stdin: !!options.passwordStdin,
+      env: options.passwordEnv,
+      message: `Enter new keystore password for account '${name}':`
+    });
+    if (!password) {
+      throw new Error("Password cannot be empty for encrypted storage.");
+    }
+    const keystore = await KeystoreManager.createEncryptedKeystore(
+      {
+        address,
+        privateKey: finalKey,
+        network: address.startsWith("kaspa:") ? "mainnet" : "devnet"
+      },
+      password,
+      {
+        label: name,
+        network: address.startsWith("kaspa:") ? "mainnet" : "devnet"
+      }
+    );
+    const keystoreDir = path.join(process.cwd(), ".hardkas", "keystore");
+    const filePath = path.join(keystoreDir, `${name}.json`);
+    await KeystoreManager.saveEncryptedKeystore(filePath, keystore);
+    keystoreRef = `.hardkas/keystore/${name}.json`;
+  }
+  let store = await loadOrCreateRealAccountStore();
+  store = importRealDevAccount(store, {
+    name,
+    address,
+    ...options.unsafePlaintext ? { privateKey: finalKey } : {},
+    ...keystoreRef ? { keystoreRef } : {}
+  });
+  await saveRealAccountStore(store);
+  const warnings = [];
+  if (privateKeyUsedAsArg) {
+    warnings.push({
+      code: "PRIVATE_KEY_ARG_DEPRECATED",
+      severity: "warning",
+      message: "--private-key is deprecated and unsafe. Use --private-key-stdin or --private-key-env."
+    });
+  }
+  return {
+    success: true,
+    name,
+    encrypted: !options.unsafePlaintext,
+    warnings,
+    formatted: options.unsafePlaintext ? `\u2713 Successfully imported account '${name}' (UNSAFE PLAINTEXT)` : `\u2713 Successfully imported and encrypted account '${name}'`
+  };
+}
+async function runAccountsSessionOpen(options) {
+  const { name } = options;
+  const filePath = path.join(process.cwd(), ".hardkas", "keystore", `${name}.json`);
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`Keystore for account '${name}' not found at ${filePath}`);
+  }
+  const keystore = await KeystoreManager.loadEncryptedKeystore(filePath);
+  const password = await acquirePassword({
+    stdin: !!options.passwordStdin,
+    env: options.passwordEnv,
+    message: `Enter password for account '${name}':`
+  });
+  const result = await KeystoreManager.decryptEncryptedKeystore(keystore, password);
+  if (result.success) {
+    UI.success(`Access to account '${name}' verified.`);
+    UI.info("Note: This does not create a production wallet session or daemon.");
+    UI.info("Decrypted key material is process-local and will not be persisted.");
+  } else {
+    throw new Error(result.error || "Failed to unlock keystore.");
+  }
+}
+async function runAccountsKeystoreChangePassword(options) {
+  const { name } = options;
+  const filePath = path.join(process.cwd(), ".hardkas", "keystore", `${name}.json`);
+  const keystore = await KeystoreManager.loadEncryptedKeystore(filePath);
+  const oldPassword = await acquirePassword({
+    message: "Enter current password:"
+  });
+  const newPassword = await acquirePassword({
+    message: "Enter new password:"
+  });
+  const confirm = await acquirePassword({
+    message: "Confirm new password:"
+  });
+  if (newPassword !== confirm) {
+    throw new Error("New passwords do not match.");
+  }
+  const updatedKeystore = await KeystoreManager.changeKeystorePassword(
+    keystore,
+    oldPassword,
+    newPassword
+  );
+  await KeystoreManager.saveEncryptedKeystore(filePath, updatedKeystore);
+  UI.success(`Successfully changed password for account '${name}'.`);
+}
+export {
+  runAccountsKeystoreChangePassword,
+  runAccountsKeystoreImport,
+  runAccountsSessionOpen
+};

package/dist/{artifact-lineage-runner-RJWQ3R3X.js → artifact-lineage-runner-TY4YTE6H.js}

@@ -1,6 +1,6 @@
 import {
   UI
-} from "./chunk-AQWQW5ZG.js";
+} from "./chunk-K7XPWWIO.js";
 
 // src/runners/artifact-lineage-runner.ts
 import {
@@ -49,7 +49,11 @@ async function runArtifactLineage(options) {
   const result = verifyLineage(artifact);
   if (!result.ok) {
     console.log("\nLineage Violations:");
-    result.issues.forEach((i) => console.log(`  \u2717 [${i.code}] ${i.message}`));
+    result.issues.forEach((i) => {
+      const prefix = i.severity === "error" ? "\u2717" : "\u26A0";
+      console.log(`  ${prefix} [${i.code}] ${i.message}`);
+    });
+    process.exitCode = 1;
   } else {
     console.log("\n\u2713 Internal lineage structure is consistent.");
   }

package/dist/bridge-local-runner-E3LICYYX.js

@@ -0,0 +1,174 @@
+import {
+  handleError
+} from "./chunk-K7XPWWIO.js";
+
+// src/runners/bridge-local-runner.ts
+import pc from "picocolors";
+import { loadHardkasConfig } from "@hardkas/config";
+async function runBridgeLocalPlan(options) {
+  try {
+    const config = await loadHardkasConfig();
+    const { planBridgeEntry, resolveBridgeLocalContext } = await import("@hardkas/bridge-local");
+    const { MockKaspaRpcClient } = await import("@hardkas/kaspa-rpc");
+    const ctx = await resolveBridgeLocalContext({
+      config,
+      sessionName: options.session,
+      from: options.from,
+      toIgra: options.toIgra
+    });
+    const amountSompi = BigInt(Math.floor(parseFloat(options.amount) * 1e8));
+    const rpc = new MockKaspaRpcClient();
+    rpc.setUtxos(ctx.l1.address, [
+      {
+        outpoint: { transactionId: "mock-utxo", index: 0 },
+        address: ctx.l1.address,
+        amountSompi: 100000000000n,
+        // 1000 KAS
+        scriptPublicKey: "mock-script"
+      }
+    ]);
+    const utxos = await rpc.getUtxosByAddress(ctx.l1.address);
+    const plan = planBridgeEntry({
+      fromAddress: ctx.l1.address,
+      targetEvmAddress: ctx.l2.address,
+      amountSompi,
+      networkId: config.config.networkId || config.config.defaultNetwork || "simnet",
+      availableUtxos: utxos.map((u) => ({ ...u, scriptPublicKey: "", blockDaaScore: u.blockDaaScore ? BigInt(u.blockDaaScore) : void 0 }))
+    });
+    if (options.json) {
+      console.log(JSON.stringify({
+        schema: "hardkas.bridgeLocalSessionPlan.v1",
+        session: {
+          source: ctx.source,
+          name: ctx.sessionName || null
+        },
+        l1: {
+          wallet: ctx.l1.walletName,
+          address: ctx.l1.address
+        },
+        l2: {
+          account: ctx.l2.accountName || null,
+          address: ctx.l2.address
+        },
+        bridge: {
+          mode: ctx.bridgeMode,
+          amount: options.amount,
+          payload: plan.serializedPayload
+        },
+        plan
+      }, (k, v) => typeof v === "bigint" ? v.toString() : v, 2));
+      return;
+    }
+    printBridgeContext(ctx, options.amount, plan.serializedPayload);
+    console.log(pc.bold("Local Bridge Entry Plan"));
+    console.log(pc.dim("----------------------------------------"));
+    console.log(`Fee (est):       ${pc.yellow(Number(plan.estimatedFeeSompi) / 1e8)} KAS`);
+    console.log(`Mass:            ${plan.estimatedMass}`);
+    console.log(pc.dim("----------------------------------------\n"));
+  } catch (e) {
+    handleError(e);
+  }
+}
+async function runBridgeLocalSimulate(options) {
+  try {
+    const config = await loadHardkasConfig();
+    const { planBridgeEntry, simulatePrefixMining, resolveBridgeLocalContext } = await import("@hardkas/bridge-local");
+    const { MockKaspaRpcClient } = await import("@hardkas/kaspa-rpc");
+    const ctx = await resolveBridgeLocalContext({
+      config,
+      sessionName: options.session,
+      from: options.from,
+      toIgra: options.toIgra
+    });
+    const amountSompi = BigInt(Math.floor(parseFloat(options.amount) * 1e8));
+    const rpc = new MockKaspaRpcClient();
+    rpc.setUtxos(ctx.l1.address, [
+      {
+        outpoint: { transactionId: "mock-utxo", index: 0 },
+        address: ctx.l1.address,
+        amountSompi: 100000000000n,
+        // 1000 KAS
+        scriptPublicKey: "mock-script"
+      }
+    ]);
+    const utxos = await rpc.getUtxosByAddress(ctx.l1.address);
+    const plan = planBridgeEntry({
+      fromAddress: ctx.l1.address,
+      targetEvmAddress: ctx.l2.address,
+      amountSompi,
+      networkId: config.config.networkId || config.config.defaultNetwork || "simnet",
+      availableUtxos: utxos.map((u) => ({ ...u, scriptPublicKey: "", blockDaaScore: u.blockDaaScore ? BigInt(u.blockDaaScore) : void 0 }))
+    });
+    if (!options.json) {
+      printBridgeContext(ctx, options.amount, plan.serializedPayload);
+      console.log(pc.bold("Bridge Entry Simulation"));
+      console.log(`${pc.cyan("Step 1:")} Planning entry transaction... OK`);
+      console.log(`${pc.cyan("Step 2:")} Simulating prefix mining for prefix "${pc.white(options.prefix)}"...`);
+    }
+    const miningResult = simulatePrefixMining(plan.bridgePayload, options.prefix);
+    if (options.json) {
+      console.log(JSON.stringify({
+        schema: "hardkas.bridgeLocalSessionSimulation.v1",
+        status: "success",
+        session: {
+          source: ctx.source,
+          name: ctx.sessionName || null
+        },
+        l1: {
+          wallet: ctx.l1.walletName,
+          address: ctx.l1.address
+        },
+        l2: {
+          account: ctx.l2.accountName || null,
+          address: ctx.l2.address
+        },
+        miningResult,
+        plan
+      }, (k, v) => typeof v === "bigint" ? v.toString() : v, 2));
+      return;
+    }
+    console.log(`  ${pc.green("\u2713")} Target found at nonce: ${pc.white(miningResult.nonce)}`);
+    console.log(`  ${pc.green("\u2713")} Attempts: ${miningResult.attempts}`);
+    console.log(`  ${pc.green("\u2713")} Simulated Hash: ${pc.dim(miningResult.hash)}`);
+    console.log(`
+${pc.bold(pc.green("SUCCESS"))}: Local bridge entry simulated.`);
+    console.log(pc.yellow(pc.bold("\n\u26A0\uFE0F  SIMULATION DISCLAIMER:")));
+    console.log(`  - ${pc.white("NO actual bridge settlement")} occurred on L1.`);
+    console.log(`  - ${pc.white("NO L2 minting")} or state change occurred on Igra.`);
+    console.log(`  - ${pc.white("NO real bridge validation")} or relayer action was involved.`);
+    console.log(`  - This is a ${pc.bold("deterministic local proof")} for development workflows only.
+`);
+  } catch (e) {
+    handleError(e);
+  }
+}
+async function runBridgeLocalInspect(txid, options) {
+  try {
+    console.log(pc.bold(`
+Inspecting Local Bridge Transaction: ${txid}`));
+    console.log(pc.dim("Feature limited in alpha: no local tx store yet."));
+  } catch (e) {
+    handleError(e);
+  }
+}
+function printBridgeContext(ctx, amount, payload) {
+  console.log(pc.bold("\nSession"));
+  console.log(`  Source: ${pc.white(ctx.source)}`);
+  console.log(`  Name:   ${pc.white(ctx.sessionName || "none")}`);
+  console.log(pc.bold("\nKaspa L1"));
+  console.log(`  Wallet:  ${pc.white(ctx.l1.walletName)}`);
+  console.log(`  Address: ${pc.dim(ctx.l1.address)}`);
+  console.log(pc.bold("\nIgra L2"));
+  console.log(`  Account: ${pc.white(ctx.l2.accountName || "explicit")}`);
+  console.log(`  Address: ${pc.dim(ctx.l2.address)}`);
+  console.log(pc.bold("\nBridge"));
+  console.log(`  Mode:    ${pc.white(ctx.bridgeMode)}`);
+  console.log(`  Amount:  ${pc.green(amount)} KAS`);
+  console.log(`  Payload: ${pc.dim(payload)}`);
+  console.log("");
+}
+export {
+  runBridgeLocalInspect,
+  runBridgeLocalPlan,
+  runBridgeLocalSimulate
+};

package/dist/{chunk-AQWQW5ZG.js → chunk-K7XPWWIO.js}

@@ -32,6 +32,17 @@ var UI = {
   \u26A0\uFE0F  WARNING:`));
     console.log(pc.yellow(`     ${masked}`));
   },
+  securityWarning(code, message, suggestion) {
+    console.log(pc.yellow(`
+  \u26A0\uFE0F  SECURITY WARNING [${code}]:`));
+    console.log(pc.yellow(`     ${message}`));
+    if (suggestion) {
+      console.log(pc.cyan(`
+  \u{1F4A1} Suggestion:`));
+      console.log(pc.cyan(`     ${suggestion}`));
+    }
+    console.log("");
+  },
   error(msg, suggestion) {
     const maskedMsg = maskSecrets(msg);
     const maskedSuggestion = suggestion ? maskSecrets(suggestion) : void 0;
@@ -114,8 +125,41 @@ Suggestion:
   }
   UI.error(context ? `${context}: ${msg}` : msg, suggestion);
 }
+function handleLockError(e) {
+  const code = e.code || "UNKNOWN_ERROR";
+  const meta = e.cause;
+  if (code === "LOCK_HELD" || code === "LOCK_TIMEOUT" || code === "STALE_LOCK") {
+    const title = code === "STALE_LOCK" ? "Stale Workspace Lock Detected" : "Workspace is locked by another HardKAS process";
+    console.error(pc.red(`
+  \u2717 ${pc.bold(title)}`));
+    console.error(pc.red(`  ${"\u2500".repeat(title.length + 4)}`));
+    if (meta) {
+      console.error(`  ${pc.dim("Lock:")}    ${pc.white(meta.name)}`);
+      console.error(`  ${pc.dim("PID:")}     ${pc.white(meta.pid)}`);
+      console.error(`  ${pc.dim("Command:")} ${pc.white(meta.command)}`);
+      console.error(`  ${pc.dim("Created:")} ${pc.white(meta.createdAt)}`);
+      if (meta.path) console.error(`  ${pc.dim("Path:")}    ${pc.white(meta.path)}`);
+    }
+    console.error(pc.cyan(`
+  \u{1F4A1} Suggestion:`));
+    if (code === "STALE_LOCK") {
+      console.error(`    The process (PID ${meta?.pid}) appears to be dead.`);
+      console.error(`    Run 'hardkas lock clear ${meta?.name} --if-dead' to release it safely.`);
+    } else {
+      console.error(`    Wait for the process to finish, or run:`);
+      console.error(`    hardkas lock doctor`);
+      console.error(`
+    If you believe the process is dead:`);
+      console.error(`    hardkas lock clear ${meta?.name} --if-dead`);
+    }
+    console.error("");
+    return;
+  }
+  handleError(e);
+}
 
 export {
   UI,
-  handleError
+  handleError,
+  handleLockError
 };

package/dist/chunk-KA5CAWI2.js

@@ -0,0 +1,163 @@
+import {
+  UI
+} from "./chunk-K7XPWWIO.js";
+
+// src/runners/deployment-runners.ts
+import { withLock } from "@hardkas/core";
+import {
+  saveDeployment,
+  loadDeployment,
+  listDeployments,
+  createDeploymentRecord,
+  updateDeploymentStatus
+} from "@hardkas/artifacts";
+import { loadHardkasConfig, resolveNetworkTarget } from "@hardkas/config";
+import { JsonWrpcKaspaClient } from "@hardkas/kaspa-rpc";
+async function trackDeployment(opts) {
+  const rootDir = process.cwd();
+  await withLock({ rootDir, name: "artifacts", command: "hardkas deploy track" }, async () => {
+    const existing = await loadDeployment(rootDir, opts.network, opts.label);
+    if (existing) {
+      throw new Error(`Deployment '${opts.label}' already exists on network '${opts.network}'.`);
+    }
+    const record = createDeploymentRecord({
+      label: opts.label,
+      networkId: opts.network,
+      ...opts.txId ? { txId: opts.txId } : {},
+      ...opts.plan ? { planArtifactId: opts.plan } : {},
+      ...opts.receipt ? { receiptArtifactId: opts.receipt } : {},
+      status: opts.status || "sent",
+      ...opts.notes ? { notes: opts.notes } : {}
+    });
+    await saveDeployment(rootDir, record);
+    UI.success(`Tracked deployment: ${opts.label} (${opts.network})`);
+  });
+}
+async function listAllDeployments(opts) {
+  const rootDir = process.cwd();
+  const deployments = await listDeployments(rootDir, opts.network);
+  const filtered = opts.status ? deployments.filter((d) => d.status === opts.status) : deployments;
+  if (opts.json) {
+    console.log(JSON.stringify(filtered, null, 2));
+    return;
+  }
+  if (filtered.length === 0) {
+    UI.info("No deployments found.");
+    return;
+  }
+  UI.header("Deployments");
+  const byNetwork = {};
+  for (const d of filtered) {
+    const net = d.networkId || "unknown";
+    if (!byNetwork[net]) byNetwork[net] = [];
+    byNetwork[net].push(d);
+  }
+  let total = 0;
+  for (const [net, items] of Object.entries(byNetwork)) {
+    console.log(`
+  ${net}`);
+    for (const d of items) {
+      const statusIcon = d.status === "confirmed" ? "\u2705" : d.status === "failed" ? "\u274C" : "\u23F3";
+      const txIdShort = d.txId ? d.txId.slice(0, 12) + "..." : "(none)";
+      const ago = formatAgo(d.deployedAt);
+      console.log(`    ${statusIcon} ${d.label.padEnd(20)} ${d.status.padEnd(10)} ${txIdShort.padEnd(16)} ${ago}`);
+      total++;
+    }
+  }
+  console.log(`
+  Total: ${total} deployments across ${Object.keys(byNetwork).length} networks`);
+}
+async function inspectDeployment(opts) {
+  const rootDir = process.cwd();
+  const record = await loadDeployment(rootDir, opts.network, opts.label);
+  if (!record) {
+    throw new Error(`Deployment '${opts.label}' not found on network '${opts.network}'.`);
+  }
+  if (opts.json) {
+    console.log(JSON.stringify(record, null, 2));
+    return;
+  }
+  UI.header(`Deployment: ${record.label}`);
+  console.log(`  Network:        ${record.networkId}`);
+  console.log(`  Status:         ${record.status}`);
+  console.log(`  TxId:           ${record.txId || "(none)"}`);
+  console.log(`  Plan artifact:  ${record.planArtifactId || "(none)"}`);
+  console.log(`  Receipt:        ${record.receiptArtifactId || "(none)"}`);
+  console.log(`  Deployed at:    ${record.deployedAt}`);
+  console.log(`  Content hash:   ${record.contentHash}`);
+  if (record.notes) console.log(`  Notes:          ${record.notes}`);
+}
+async function verifyDeploymentStatus(opts) {
+  const rootDir = process.cwd();
+  const record = await loadDeployment(rootDir, opts.network, opts.label);
+  if (!record) {
+    throw new Error(`Deployment '${opts.label}' not found on network '${opts.network}'.`);
+  }
+  if (!opts.verify) {
+    if (opts.json) console.log(JSON.stringify({ label: record.label, status: record.status }, null, 2));
+    else console.log(`Current status: ${record.status}`);
+    return;
+  }
+  if (!record.txId) {
+    throw new Error(`Cannot verify deployment '${opts.label}' without a transaction ID.`);
+  }
+  UI.info(`Checking ${record.label} on ${record.networkId}...`);
+  const { config } = await loadHardkasConfig();
+  const netTarget = resolveNetworkTarget({ config, network: record.networkId });
+  const rpcUrl = netTarget.target.rpcUrl;
+  console.log(`  RPC: ${rpcUrl || "simulated"}`);
+  console.log(`  TxId: ${record.txId}`);
+  if (record.networkId === "simnet") {
+    UI.info("  Simnet deployment \u2014 status preserved.");
+  } else if (!rpcUrl) {
+    UI.error("  No RPC URL configured for this network.");
+  } else {
+    try {
+      const client = new JsonWrpcKaspaClient({ rpcUrl });
+      const tx = await client.getTransaction(record.txId);
+      let newStatus = record.status;
+      if (tx) {
+        const isAccepted = tx.isAccepted || tx.transaction && tx.transaction.block_hash;
+        if (isAccepted) newStatus = "confirmed";
+      } else {
+      }
+      if (newStatus !== record.status) {
+        await withLock({ rootDir, name: "artifacts", command: "hardkas deploy status" }, async () => {
+          const updated = updateDeploymentStatus(record, newStatus);
+          await saveDeployment(rootDir, updated);
+          UI.success(`  Status updated: ${newStatus}`);
+        });
+      } else {
+        UI.info(`  Status remains: ${record.status}`);
+      }
+      await client.close();
+    } catch (e) {
+      UI.error(`  RPC check failed: ${e.message}`);
+    }
+  }
+}
+async function showDeploymentHistory(opts) {
+  const options = {
+    ...opts.json !== void 0 ? { json: opts.json } : {}
+  };
+  await listAllDeployments(options);
+}
+function formatAgo(dateStr) {
+  const date = new Date(dateStr);
+  const now = /* @__PURE__ */ new Date();
+  const diffMs = now.getTime() - date.getTime();
+  const diffMin = Math.floor(diffMs / 6e4);
+  if (diffMin < 1) return "just now";
+  if (diffMin < 60) return `${diffMin} min ago`;
+  const diffHour = Math.floor(diffMin / 60);
+  if (diffHour < 24) return `${diffHour} hours ago`;
+  return `${Math.floor(diffHour / 24)} days ago`;
+}
+
+export {
+  trackDeployment,
+  listAllDeployments,
+  inspectDeployment,
+  verifyDeploymentStatus,
+  showDeploymentHistory
+};

package/dist/chunk-ZM2NBOAE.js

@@ -0,0 +1,37 @@
+// src/runners/secrets.ts
+import enquirer from "enquirer";
+var { Password } = enquirer;
+async function acquirePassword(options = {}) {
+  if (options.env && process.env[options.env]) {
+    return process.env[options.env];
+  }
+  if (options.stdin) {
+    return new Promise((resolve, reject) => {
+      let data = "";
+      process.stdin.setEncoding("utf8");
+      process.stdin.on("data", (chunk) => {
+        data += chunk;
+      });
+      process.stdin.on("end", () => {
+        resolve(data.trim());
+      });
+      process.stdin.on("error", reject);
+    });
+  }
+  const prompt = new Password({
+    name: "password",
+    message: options.message || "Enter password:"
+  });
+  return await prompt.run();
+}
+async function acquirePrivateKey(options = {}) {
+  return acquirePassword({
+    ...options,
+    message: options.message || "Enter private key (hex):"
+  });
+}
+
+export {
+  acquirePassword,
+  acquirePrivateKey
+};

package/dist/{dag-runners-YQDHD7U6.js → dag-runners-NLBYR7I7.js}

@@ -1,6 +1,6 @@
 import {
   UI
-} from "./chunk-AQWQW5ZG.js";
+} from "./chunk-K7XPWWIO.js";
 
 // src/runners/dag-runners.ts
 import {
@@ -49,7 +49,7 @@ async function runDagSimulateReorg(options) {
   if (!forkPointId) throw new Error("Could not find fork point in current path.");
   const forkPoint = state.dag.blocks[forkPointId];
   if (!forkPoint) throw new Error(`Fork point block ${forkPointId} not found in state.`);
-  const sideBlockId = `reorg_side_${Date.now().toString(36)}`;
+  const sideBlockId = `reorg_side_${forkPointId}_0`;
   state.dag.blocks[sideBlockId] = {
     id: sideBlockId,
     parents: [forkPointId],

package/dist/deployment-runners-GEICABEH.js

@@ -0,0 +1,15 @@
+import {
+  inspectDeployment,
+  listAllDeployments,
+  showDeploymentHistory,
+  trackDeployment,
+  verifyDeploymentStatus
+} from "./chunk-KA5CAWI2.js";
+import "./chunk-K7XPWWIO.js";
+export {
+  inspectDeployment,
+  listAllDeployments,
+  showDeploymentHistory,
+  trackDeployment,
+  verifyDeploymentStatus
+};