@hardkas/cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Javier Rodriguez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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

@@ -0,0 +1,112 @@
+import {
+  UI
+} from "./chunk-M54KNJEH.js";
+
+// src/runners/accounts-keystore-runners.ts
+import path from "path";
+import enquirer from "enquirer";
+import { KeystoreManager } from "@hardkas/accounts";
+var { Password } = enquirer;
+async function runAccountsKeystoreImport(options) {
+  const name = options.name || "default";
+  const address = options.address;
+  const privateKey = options.privateKey;
+  if (!options.encrypted) {
+    throw new Error("Plaintext import is handled by runAccountsRealImport. Use --encrypted for this runner.");
+  }
+  UI.warning("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 || !privateKey) {
+    throw new Error("Address and private key are required for import.");
+  }
+  const passwordPrompt = new Password({
+    name: "password",
+    message: "Enter keystore password:"
+  });
+  const password = await passwordPrompt.run();
+  if (!password) {
+    throw new Error("Password cannot be empty.");
+  }
+  const confirmPrompt = new Password({
+    name: "confirm",
+    message: "Confirm keystore password:"
+  });
+  const confirm = await confirmPrompt.run();
+  if (password !== confirm) {
+    throw new Error("Passwords do not match.");
+  }
+  const keystore = await KeystoreManager.createEncryptedKeystore(
+    {
+      address,
+      privateKey,
+      network: "devnet"
+      // Default for now
+    },
+    password,
+    {
+      label: name,
+      network: "devnet"
+    }
+  );
+  const keystoreDir = path.join(process.cwd(), ".hardkas", "keystore");
+  const filePath = path.join(keystoreDir, `${name}.json`);
+  await KeystoreManager.saveEncryptedKeystore(filePath, keystore);
+  return {
+    success: true,
+    name,
+    path: filePath,
+    formatted: `Successfully imported and encrypted account '${name}' to ${filePath}`
+  };
+}
+async function runAccountsKeystoreUnlock(options) {
+  const { name } = options;
+  const filePath = path.join(process.cwd(), ".hardkas", "keystore", `${name}.json`);
+  const keystore = await KeystoreManager.loadEncryptedKeystore(filePath);
+  const passwordPrompt = new Password({
+    name: "password",
+    message: `Enter password for account '${name}':`
+  });
+  const password = await passwordPrompt.run();
+  const result = await KeystoreManager.decryptEncryptedKeystore(keystore, password);
+  if (result.success) {
+    UI.success(`Password verified for account '${name}'.`);
+    UI.info("Unlock is session-only. Decrypted key is not 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 oldPasswordPrompt = new Password({
+    name: "old",
+    message: "Enter current password:"
+  });
+  const oldPassword = await oldPasswordPrompt.run();
+  const newPasswordPrompt = new Password({
+    name: "new",
+    message: "Enter new password:"
+  });
+  const newPassword = await newPasswordPrompt.run();
+  const confirmPrompt = new Password({
+    name: "confirm",
+    message: "Confirm new password:"
+  });
+  const confirm = await confirmPrompt.run();
+  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,
+  runAccountsKeystoreUnlock
+};

package/dist/artifact-lineage-runner-EPT6ABS2.js

@@ -0,0 +1,60 @@
+import {
+  UI
+} from "./chunk-M54KNJEH.js";
+
+// src/runners/artifact-lineage-runner.ts
+import {
+  verifyLineage
+} from "@hardkas/artifacts";
+import fs from "fs";
+import path from "path";
+async function runArtifactLineage(options) {
+  const absolutePath = path.resolve(process.cwd(), options.path);
+  if (!fs.existsSync(absolutePath)) {
+    UI.error(`File not found: ${options.path}`);
+    process.exitCode = 1;
+    return;
+  }
+  const content = fs.readFileSync(absolutePath, "utf-8");
+  const artifact = JSON.parse(content);
+  UI.header(`Artifact Lineage: ${path.basename(options.path)}`);
+  const lineage = artifact.lineage;
+  if (!lineage) {
+    UI.warning("No lineage metadata found in this artifact.");
+    UI.info("Artifact is an 'orphan' (Provenance cannot be verified).");
+    return;
+  }
+  console.log("\u2550".repeat(60));
+  console.log(`Lineage ID:    ${lineage.lineageId}`);
+  console.log(`Root Artifact: ${lineage.rootArtifactId}`);
+  console.log(`Current ID:    ${lineage.artifactId}`);
+  console.log(`Parent ID:     ${lineage.parentArtifactId || "None (Root)"}`);
+  if (lineage.sequence !== void 0) {
+    console.log(`Sequence:      ${lineage.sequence}`);
+  }
+  console.log("\u2550".repeat(60));
+  console.log("\nPROVENANCE CHAIN:");
+  const chain = [];
+  if (lineage.rootArtifactId === lineage.artifactId) {
+    chain.push(`[ROOT] ${artifact.schema} (${lineage.artifactId.slice(0, 8)}...)`);
+  } else {
+    chain.push(`[ROOT] ${lineage.rootArtifactId.slice(0, 8)}...`);
+    chain.push(`  \u2193    (Intermediate Artifacts)`);
+    if (lineage.parentArtifactId) {
+      chain.push(`  \u2193    ${lineage.parentArtifactId.slice(0, 8)}... (Parent)`);
+    }
+    chain.push(`[HERE] ${artifact.schema} (${lineage.artifactId.slice(0, 8)}...)`);
+  }
+  chain.forEach((step) => console.log(`  ${step}`));
+  const result = verifyLineage(artifact);
+  if (!result.ok) {
+    console.log("\nLineage Violations:");
+    result.issues.forEach((i) => console.log(`  \u2717 [${i.code}] ${i.message}`));
+  } else {
+    console.log("\n\u2713 Internal lineage structure is consistent.");
+  }
+  UI.footer("Operational Provenance Complete");
+}
+export {
+  runArtifactLineage
+};

package/dist/chunk-M54KNJEH.js

@@ -0,0 +1,98 @@
+// src/ui.ts
+import pc from "picocolors";
+import { formatSompi } from "@hardkas/core";
+var UI = {
+  header(text) {
+    console.log(pc.bold(pc.magenta(`
+  \u2550\u2550\u2550 ${text} \u2550\u2550\u2550`)));
+  },
+  divider() {
+    console.log(pc.dim("  " + "\u2500".repeat(50)));
+  },
+  info(text) {
+    console.log(`  ${pc.blue("\u2139")} ${text}`);
+  },
+  success(text) {
+    console.log(`  ${pc.green("\u2714")} ${text}`);
+  },
+  box(title, subtitle) {
+    const width = 40;
+    console.log(pc.magenta(`  \u2554${"\u2550".repeat(width - 2)}\u2557`));
+    console.log(pc.magenta(`  \u2551${pc.bold(pc.white(title.padStart((width - 2 + title.length) / 2).padEnd(width - 2)))}\u2551`));
+    if (subtitle) {
+      console.log(pc.magenta(`  \u2551${pc.italic(pc.dim(subtitle.padStart((width - 2 + subtitle.length) / 2).padEnd(width - 2)))}\u2551`));
+    }
+    console.log(pc.magenta(`  \u255A${"\u2550".repeat(width - 2)}\u255D`));
+    console.log("");
+  },
+  warning(text) {
+    console.log(pc.yellow(`
+  \u26A0\uFE0F  WARNING:`));
+    console.log(pc.yellow(`     ${text}`));
+  },
+  error(msg, suggestion) {
+    console.error(pc.red(`
+  \u2717 Error:`));
+    console.error(pc.red(`    ${msg}`));
+    if (suggestion) {
+      console.error(pc.cyan(`
+  \u{1F4A1} Suggestion:`));
+      console.error(pc.cyan(`    ${suggestion}`));
+    }
+  },
+  field(label, value) {
+    const val = value === void 0 || value === null ? pc.dim("none") : String(value);
+    console.log(`  ${pc.dim(label.padEnd(16))} ${pc.white(val)}`);
+  },
+  kas(label, sompi) {
+    this.field(label, pc.cyan(formatSompi(BigInt(sompi))));
+  },
+  footer(hint) {
+    if (hint) {
+      console.log(pc.dim(`
+  Hint: ${hint}`));
+    }
+    console.log("");
+  }
+};
+function handleError(e, context) {
+  const msg = e instanceof Error ? e.message : String(e);
+  const errorObj = e;
+  let reason = errorObj.reason;
+  let suggestion = errorObj.suggestion;
+  if (msg === "Real transaction signing is not available") {
+    console.error(`
+${msg}`);
+    if (reason) console.error(`
+Reason:
+  ${reason}`);
+    if (suggestion) console.error(`
+Suggestion:
+  ${suggestion}
+  No artifact was written.`);
+    return;
+  }
+  if (!suggestion) {
+    if (msg.includes("Localnet state not found")) {
+      suggestion = "Run 'hardkas localnet reset' to initialize the simulated environment.";
+    } else if (msg.includes("Insufficient funds")) {
+      suggestion = "Use 'hardkas faucet <address> <amount>' to add funds to your account.";
+    } else if (msg.includes("Account not found")) {
+      suggestion = "Check your 'hardkas.config.ts' or use a full Kaspa address.";
+    } else if (msg.includes("Docker") || msg.includes("container")) {
+      suggestion = "Ensure Docker is running and you have permissions to manage containers.";
+    } else if (msg.includes("L2 RPC") || msg.includes("L2 profile")) {
+      suggestion = "Check your L2 network configuration or pass a valid --url.";
+    } else if (msg.includes("RPC") || msg.includes("Connection refused")) {
+      suggestion = "The Kaspa node might still be starting. Try 'hardkas rpc health --wait'.";
+    } else if (msg.includes("submitTransaction is not exposed")) {
+      suggestion = "Ensure your node/RPC provider supports transaction submission and you are NOT on mainnet without --allow-mainnet-signing.";
+    }
+  }
+  UI.error(context ? `${context}: ${msg}` : msg, suggestion);
+}
+
+export {
+  UI,
+  handleError
+};

package/dist/dag-runners-BQAKJ6DM.js

@@ -0,0 +1,70 @@
+import {
+  UI
+} from "./chunk-M54KNJEH.js";
+
+// src/runners/dag-runners.ts
+import {
+  loadOrCreateLocalnetState,
+  saveLocalnetState,
+  createSimulatedDag,
+  moveSink
+} from "@hardkas/localnet";
+async function runDagStatus() {
+  const state = await loadOrCreateLocalnetState();
+  if (!state.dag) {
+    UI.info("DAG simulation is not initialized in this localnet.");
+    UI.info("Hint: Use 'hardkas dag status' again after DAG operations or manual init.");
+    return;
+  }
+  UI.header("DAG Status (Light-Model)");
+  UI.field("Mode", state.dag.blocks["genesis"] ? "dag-light" : "linear");
+  UI.field("Sink", state.dag.sink);
+  UI.field("Blocks", Object.keys(state.dag.blocks).length);
+  UI.field("Selected Path", state.dag.selectedPathToSink.join(" -> "));
+  UI.info(`
+Accepted Transactions (${state.dag.acceptedTxIds.length}):`);
+  if (state.dag.acceptedTxIds.length > 0) {
+    state.dag.acceptedTxIds.forEach((id) => console.log(`  - ${id}`));
+  } else {
+    UI.info("  None");
+  }
+  UI.info(`
+Displaced Transactions (${state.dag.displacedTxIds.length}):`);
+  if (state.dag.displacedTxIds.length > 0) {
+    state.dag.displacedTxIds.forEach((id) => console.log(`  - ${id}`));
+  } else {
+    UI.info("  None");
+  }
+}
+async function runDagSimulateReorg(options) {
+  const state = await loadOrCreateLocalnetState();
+  if (!state.dag) {
+    UI.info("Initializing DAG light-model for this localnet...");
+    state.dag = createSimulatedDag();
+  }
+  UI.info(`Simulating reorg at depth ${options.depth}...`);
+  const currentPath = state.dag.selectedPathToSink;
+  const forkPointIndex = Math.max(0, currentPath.length - 1 - options.depth);
+  const forkPointId = currentPath[forkPointIndex];
+  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)}`;
+  state.dag.blocks[sideBlockId] = {
+    id: sideBlockId,
+    parents: [forkPointId],
+    blueScore: (BigInt(forkPoint.blueScore || "0") + 1n).toString(),
+    daaScore: (BigInt(forkPoint.daaScore || "0") + 1n).toString(),
+    acceptedTxIds: []
+  };
+  const txProvider = (_id) => void 0;
+  state.dag = moveSink(state.dag, sideBlockId, txProvider);
+  await saveLocalnetState(state);
+  UI.success("Reorg simulation complete.");
+  UI.info(`New Sink: ${state.dag.sink}`);
+  UI.info(`Selected Path: ${state.dag.selectedPathToSink.join(" -> ")}`);
+}
+export {
+  runDagSimulateReorg,
+  runDagStatus
+};