@bcts/seedtool-cli 1.0.0-alpha.14 → 1.0.0-alpha.16

package/src/cli.ts

@@ -3,10 +3,10 @@
  * Ported from seedtool-cli-rust/src/cli.rs
  */
 
-import * as readline from "readline";
+import * as readline from "node:readline";
 import { SSKRGroupSpec, SSKRSpec } from "@bcts/components";
-import { Envelope } from "@bcts/envelope";
-import { SecureRandomNumberGenerator } from "@bcts/rand";
+import type { SecureRandomNumberGenerator } from "@bcts/rand";
+import type { Envelope } from "@bcts/envelope";
 import type { Seed } from "./seed.js";
 import type { DeterministicRandomNumberGenerator } from "./random.js";
 
@@ -144,8 +144,9 @@ export function parseDate(s: string): Date {
  * Returns SSKRGroupSpec instance.
  */
 export function parseGroupSpec(s: string): SSKRGroupSpec {
-  const match = s.match(/^(\d+)-of-(\d+)$/i);
-  if (!match) {
+  const regex = /^(\d+)-of-(\d+)$/i;
+  const match = regex.exec(s);
+  if (match === null) {
     throw new Error(`Invalid group specification: ${s}. Use format 'M-of-N' (e.g., '2-of-3').`);
   }
   const threshold = parseInt(match[1], 10);
@@ -166,19 +167,19 @@ export class Cli {
   input?: string;
 
   /** The number of output units (hex bytes, base-10 digits, etc.) */
-  count: number = 16;
+  count = 16;
 
   /** The input format. Default: Random */
-  in: InputFormatKey = InputFormatKey.Random;
+  in = InputFormatKey.Random;
 
   /** The output format. Default: Hex */
-  out: OutputFormatKey = OutputFormatKey.Hex;
+  out = OutputFormatKey.Hex;
 
   /** The lowest int returned (0-254). Default: 0 */
-  low: number = 0;
+  low = 0;
 
   /** The highest int returned (1-255), low < high. Default: 9 */
-  high: number = 9;
+  high = 9;
 
   /** The name of the seed. */
   name?: string;
@@ -190,19 +191,19 @@ export class Cli {
   date?: Date;
 
   /** For `multipart` output, max fragment length. Default: 500 */
-  maxFragmentLen: number = 500;
+  maxFragmentLen = 500;
 
   /** For `multipart` output, additional parts for fountain encoding. Default: 0 */
-  additionalParts: number = 0;
+  additionalParts = 0;
 
   /** Group specifications for SSKR. */
   groups: SSKRGroupSpec[] = [];
 
   /** The number of groups that must meet their threshold. Default: 1 */
-  groupThreshold: number = 1;
+  groupThreshold = 1;
 
   /** SSKR output format. Default: Envelope */
-  sskrFormat: SSKRFormatKey = SSKRFormatKey.Envelope;
+  sskrFormat = SSKRFormatKey.Envelope;
 
   /** Deterministic RNG seed string. */
   deterministic?: string;
@@ -244,15 +245,15 @@ export class Cli {
         terminal: false,
       });
 
-      rl.on("line", (line) => {
-        data += line + "\n";
+      rl.on("line", (line: string) => {
+        data += `${line}\n`;
       });
 
       rl.on("close", () => {
         resolve(data.trim());
       });
 
-      rl.on("error", (err) => {
+      rl.on("error", (err: Error) => {
         reject(err);
       });
     });
@@ -323,23 +324,23 @@ export class Cli {
    */
   clone(): Cli {
     const cli = new Cli();
-    cli.input = this.input;
+    if (this.input !== undefined) cli.input = this.input;
     cli.count = this.count;
     cli.in = this.in;
     cli.out = this.out;
     cli.low = this.low;
     cli.high = this.high;
-    cli.name = this.name;
-    cli.note = this.note;
-    cli.date = this.date;
+    if (this.name !== undefined) cli.name = this.name;
+    if (this.note !== undefined) cli.note = this.note;
+    if (this.date !== undefined) cli.date = this.date;
     cli.maxFragmentLen = this.maxFragmentLen;
     cli.additionalParts = this.additionalParts;
     cli.groups = [...this.groups];
     cli.groupThreshold = this.groupThreshold;
     cli.sskrFormat = this.sskrFormat;
-    cli.deterministic = this.deterministic;
-    cli.seed = this.seed?.clone();
-    cli.rng = this.rng;
+    if (this.deterministic !== undefined) cli.deterministic = this.deterministic;
+    if (this.seed !== undefined) cli.seed = this.seed.clone();
+    if (this.rng !== undefined) cli.rng = this.rng;
     return cli;
   }
 }

package/src/formats/bip39.ts

@@ -7,7 +7,7 @@ import type { Cli } from "../cli.js";
 import type { InputFormat, OutputFormat } from "./format.js";
 import { Seed } from "../seed.js";
 import { mnemonicToEntropy, entropyToMnemonic, validateMnemonic } from "@scure/bip39";
-import { wordlist } from "@scure/bip39/wordlists/english";
+import { wordlist } from "@scure/bip39/wordlists/english.js";
 
 /**
  * BIP39 mnemonic format handler.

package/src/formats/format.ts

@@ -3,7 +3,7 @@
  * Ported from seedtool-cli-rust/src/formats/format.rs
  */
 
-import type { Cli, InputFormatKey, OutputFormatKey } from "../cli.js";
+import { InputFormatKey, OutputFormatKey, type Cli } from "../cli.js";
 
 // ============================================================================
 // Format Interfaces (Traits)
@@ -66,40 +66,38 @@ import { BytewordsUriFormat } from "./bytewords-uri.js";
  */
 export function selectInputFormat(key: InputFormatKey): InputFormat {
   switch (key) {
-    case "random":
+    case InputFormatKey.Random:
       return new RandomFormat();
-    case "hex":
+    case InputFormatKey.Hex:
       return new HexFormat();
-    case "btw":
+    case InputFormatKey.Btw:
       return new BytewordsStandardFormat();
-    case "btwu":
+    case InputFormatKey.Btwu:
       return new BytewordsUriFormat();
-    case "btwm":
+    case InputFormatKey.Btwm:
       return new BytewordsMinimalFormat();
-    case "bits":
+    case InputFormatKey.Bits:
       return new BitsFormat();
-    case "cards":
+    case InputFormatKey.Cards:
       return new CardsFormat();
-    case "dice":
+    case InputFormatKey.Dice:
       return new DiceFormat();
-    case "base6":
+    case InputFormatKey.Base6:
       return new Base6Format();
-    case "base10":
+    case InputFormatKey.Base10:
       return new Base10Format();
-    case "ints":
+    case InputFormatKey.Ints:
       return new IntsFormat();
-    case "bip39":
+    case InputFormatKey.Bip39:
       return new Bip39Format();
-    case "sskr":
+    case InputFormatKey.Sskr:
       return new SSKRFormat();
-    case "envelope":
+    case InputFormatKey.Envelope:
       return new EnvelopeFormat();
-    case "multipart":
+    case InputFormatKey.Multipart:
       return new MultipartFormat();
-    case "seed":
+    case InputFormatKey.Seed:
       return new SeedFormat();
-    default:
-      throw new Error(`Unknown input format: ${key}`);
   }
 }
 
@@ -109,37 +107,35 @@ export function selectInputFormat(key: InputFormatKey): InputFormat {
  */
 export function selectOutputFormat(key: OutputFormatKey): OutputFormat {
   switch (key) {
-    case "hex":
+    case OutputFormatKey.Hex:
       return new HexFormat();
-    case "btw":
+    case OutputFormatKey.Btw:
       return new BytewordsStandardFormat();
-    case "btwu":
+    case OutputFormatKey.Btwu:
       return new BytewordsUriFormat();
-    case "btwm":
+    case OutputFormatKey.Btwm:
       return new BytewordsMinimalFormat();
-    case "bits":
+    case OutputFormatKey.Bits:
       return new BitsFormat();
-    case "cards":
+    case OutputFormatKey.Cards:
       return new CardsFormat();
-    case "dice":
+    case OutputFormatKey.Dice:
       return new DiceFormat();
-    case "base6":
+    case OutputFormatKey.Base6:
       return new Base6Format();
-    case "base10":
+    case OutputFormatKey.Base10:
       return new Base10Format();
-    case "ints":
+    case OutputFormatKey.Ints:
       return new IntsFormat();
-    case "bip39":
+    case OutputFormatKey.Bip39:
       return new Bip39Format();
-    case "sskr":
+    case OutputFormatKey.Sskr:
       return new SSKRFormat();
-    case "envelope":
+    case OutputFormatKey.Envelope:
       return new EnvelopeFormat();
-    case "multipart":
+    case OutputFormatKey.Multipart:
       return new MultipartFormat();
-    case "seed":
+    case OutputFormatKey.Seed:
       return new SeedFormat();
-    default:
-      throw new Error(`Unknown output format: ${key}`);
   }
 }

package/src/formats/multipart.ts

@@ -40,7 +40,7 @@ export class MultipartFormat implements InputFormat, OutputFormat {
     }
 
     const ur = decoder.message();
-    if (ur === undefined) {
+    if (ur === undefined || ur === null) {
       throw new Error("Failed to decode multipart message");
     }
 

package/src/formats/sskr.ts

@@ -3,15 +3,21 @@
  * Ported from seedtool-cli-rust/src/formats/sskr.rs
  */
 
-import type { Cli, SSKRFormatKey } from "../cli.js";
+import { SSKRFormatKey, type Cli } from "../cli.js";
 import type { InputFormat, OutputFormat } from "./format.js";
 import { Seed } from "../seed.js";
-import { Envelope } from "@bcts/envelope";
-import { SymmetricKey } from "@bcts/envelope";
-import { SSKRShare, SSKRShareCbor, SSKRSecret, sskrGenerate, sskrCombine } from "@bcts/components";
+import { Envelope, SymmetricKey } from "@bcts/envelope";
+import {
+  SSKRShare,
+  SSKRSecret,
+  sskrGenerate,
+  sskrCombine,
+  type SSKRShareCbor,
+} from "@bcts/components";
 import { encodeBytewords, decodeBytewords, BytewordsStyle, UR } from "@bcts/uniform-resources";
 import { SSKR_SHARE, SSKR_SHARE_V1 } from "@bcts/tags";
 import { toByteString, toTaggedValue, decodeCbor, expectBytes } from "@bcts/dcbor";
+import type { Spec } from "@bcts/sskr";
 
 /**
  * SSKR format handler.
@@ -45,33 +51,35 @@ export class SSKRFormat implements InputFormat, OutputFormat {
 // Output Helpers
 //
 
-function outputSskrSeed(
-  seed: Seed,
-  spec: import("@bcts/sskr").Spec,
-  format: SSKRFormatKey,
-): string {
+function outputSskrSeed(seed: Seed, spec: Spec, format: SSKRFormatKey): string {
   switch (format) {
-    case "envelope": {
-      const envelope = seed.toEnvelope();
+    case SSKRFormatKey.Envelope: {
+      const seedEnvelope = seed.toEnvelope();
       const contentKey = SymmetricKey.new();
-      const encryptedEnvelope = envelope.wrap().encryptSubject(contentKey);
-      const shareEnvelopes = encryptedEnvelope.sskrSplitFlattened(spec, contentKey);
-      const shareEnvelopesStrings = shareEnvelopes.map((envelope) => envelope.urString());
+      const encryptedEnvelope = seedEnvelope.wrap().encryptSubject(contentKey);
+      // Use type assertion for prototype extension method
+      const shareEnvelopes: Envelope[] = (
+        encryptedEnvelope as unknown as {
+          sskrSplitFlattened: (spec: Spec, key: SymmetricKey) => Envelope[];
+        }
+      ).sskrSplitFlattened(spec, contentKey);
+
+      const shareEnvelopesStrings: string[] = shareEnvelopes.map((env: Envelope) => env.urString());
       return shareEnvelopesStrings.join("\n");
     }
-    case "btw": {
+    case SSKRFormatKey.Btw: {
       return makeBytewordsShares(spec, seed, BytewordsStyle.Standard);
     }
-    case "btwm": {
+    case SSKRFormatKey.Btwm: {
       return makeBytewordsShares(spec, seed, BytewordsStyle.Minimal);
     }
-    case "btwu": {
+    case SSKRFormatKey.Btwu: {
       return makeBytewordsShares(spec, seed, BytewordsStyle.Uri);
     }
-    case "ur": {
+    case SSKRFormatKey.Ur: {
       const shares = makeShares(spec, seed);
-      const urStrings = shares.map((share) => {
-        const ur = UR.fromCbor("sskr", toByteString(share.asBytes()));
+      const urStrings: string[] = shares.map((share) => {
+        const ur = UR.new("sskr", toByteString(share.asBytes()));
         return ur.toString();
       });
       return urStrings.join("\n");
@@ -79,7 +87,7 @@ function outputSskrSeed(
   }
 }
 
-function makeShares(spec: import("@bcts/sskr").Spec, seed: Seed): SSKRShareCbor[] {
+function makeShares(spec: Spec, seed: Seed): SSKRShareCbor[] {
   const secret = SSKRSecret.new(seed.data());
   const shareGroups = sskrGenerate(spec, secret);
   const flatShares: SSKRShareCbor[] = [];
@@ -91,11 +99,7 @@ function makeShares(spec: import("@bcts/sskr").Spec, seed: Seed): SSKRShareCbor[
   return flatShares;
 }
 
-function makeBytewordsShares(
-  spec: import("@bcts/sskr").Spec,
-  seed: Seed,
-  style: BytewordsStyle,
-): string {
+function makeBytewordsShares(spec: Spec, seed: Seed, style: BytewordsStyle): string {
   const shares = makeShares(spec, seed);
   const cborShares = shares.map((share) =>
     toTaggedValue(SSKR_SHARE.value, toByteString(share.asBytes())),
@@ -125,7 +129,11 @@ function parseEnvelopes(input: string): Seed | null {
       return null;
     }
 
-    const recoveredEnvelope = Envelope.sskrJoin(shareEnvelopes).unwrap();
+    // Use type assertion for static prototype extension method
+    const sskrJoin = (Envelope as unknown as { sskrJoin: (envelopes: Envelope[]) => Envelope })
+      .sskrJoin;
+    const recoveredEnvelope: Envelope = sskrJoin(shareEnvelopes).unwrap();
+
     return Seed.fromEnvelope(recoveredEnvelope);
   } catch {
     return null;
@@ -151,8 +159,9 @@ function fromTaggedCborShares(taggedCborDataShares: Uint8Array[]): Seed | null {
       if (tagged.tag !== SSKR_SHARE.value && tagged.tag !== SSKR_SHARE_V1.value) {
         return null;
       }
-      const content = (tagged.value as { buffer?: Uint8Array }) || cbor;
-      const bytes = expectBytes(content as ReturnType<typeof decodeCbor>);
+      const content =
+        tagged.value !== undefined ? (tagged.value as ReturnType<typeof decodeCbor>) : cbor;
+      const bytes = expectBytes(content);
       untaggedShares.push(bytes);
     }
     return fromUntaggedCborShares(untaggedShares);
@@ -214,7 +223,7 @@ function parseUr(input: string, expectedTagValue: number, allowTaggedCbor: boole
 
     // Ensure every UR is of the expected type
     for (const ur of urs) {
-      if (ur.type() !== expectedType) {
+      if (ur.urTypeStr() !== expectedType) {
         return null;
       }
     }
@@ -275,13 +284,13 @@ function parseSskrSeed(input: string): Seed {
   }
 
   // Try UR format (current tag)
-  const urResult = parseUr(input, SSKR_SHARE.value, false);
+  const urResult = parseUr(input, Number(SSKR_SHARE.value), false);
   if (urResult !== null) {
     return urResult;
   }
 
   // Try legacy UR format (v1 tag, allow tagged cbor)
-  const urLegacyResult = parseUr(input, SSKR_SHARE_V1.value, true);
+  const urLegacyResult = parseUr(input, Number(SSKR_SHARE_V1.value), true);
   if (urLegacyResult !== null) {
     return urLegacyResult;
   }

package/src/main.ts

@@ -9,10 +9,30 @@ import { SSKRGroupSpec } from "@bcts/components";
 import { Cli, type InputFormatKey, type OutputFormatKey, type SSKRFormatKey } from "./cli.js";
 import { selectInputFormat, selectOutputFormat } from "./formats/index.js";
 import { DeterministicRandomNumberGenerator } from "./random.js";
-import * as fs from "node:fs";
+import fs from "node:fs";
 
 const VERSION = "0.4.0";
 
+/**
+ * CLI options parsed from commander.
+ */
+interface CliOptions {
+  count: string;
+  in: InputFormatKey;
+  out: OutputFormatKey;
+  low: number;
+  high: number;
+  name?: string;
+  note?: string;
+  date?: string;
+  maxFragmentLen: string;
+  additionalParts: string;
+  groups: SSKRGroupSpec[];
+  groupThreshold: number;
+  sskrFormat: SSKRFormatKey;
+  deterministic?: string;
+}
+
 function parseLowInt(value: string): number {
   const num = parseInt(value, 10);
   if (isNaN(num) || num < 0 || num > 254) {
@@ -53,7 +73,7 @@ function parseGroupSpec(value: string, previous: SSKRGroupSpec[]): SSKRGroupSpec
   return [...previous, spec];
 }
 
-async function main(): Promise<void> {
+function main(): void {
   const program = new Command();
 
   program
@@ -159,7 +179,7 @@ async function main(): Promise<void> {
 
   program.parse();
 
-  const options = program.opts();
+  const options = program.opts<CliOptions>();
   const args = program.args;
 
   // Create the CLI state
@@ -168,30 +188,30 @@ async function main(): Promise<void> {
   // Set input from argument or stdin
   if (args.length > 0) {
     cli.input = args[0];
-  } else if (!process.stdin.isTTY) {
+  } else if (process.stdin.isTTY !== true) {
     // Read from stdin if it's piped
-    cli.input = fs.readFileSync(0, "utf-8").trim();
+    cli.input = fs.readFileSync(process.stdin.fd, "utf-8").trim();
   }
 
   // Set options
   cli.count = parseInt(options.count, 10);
-  cli.in = options.in as InputFormatKey;
-  cli.out = options.out as OutputFormatKey;
+  cli.in = options.in;
+  cli.out = options.out;
   cli.low = options.low;
   cli.high = options.high;
-  cli.name = options.name;
-  cli.note = options.note;
-  if (options.date) {
+  if (options.name !== undefined) cli.name = options.name;
+  if (options.note !== undefined) cli.note = options.note;
+  if (options.date !== undefined) {
     cli.date = parseCliDate(options.date);
   }
   cli.maxFragmentLen = parseInt(options.maxFragmentLen, 10);
   cli.additionalParts = parseInt(options.additionalParts, 10);
   cli.groups = options.groups;
   cli.groupThreshold = options.groupThreshold;
-  cli.sskrFormat = options.sskrFormat as SSKRFormatKey;
+  cli.sskrFormat = options.sskrFormat;
 
   // Set up RNG
-  if (options.deterministic) {
+  if (options.deterministic !== undefined) {
     cli.rng = {
       type: "deterministic",
       rng: DeterministicRandomNumberGenerator.newWithSeed(options.deterministic),
@@ -210,7 +230,7 @@ async function main(): Promise<void> {
   // Validate round-trippability
   if (!outputFormat.roundTrippable() && inputFormat.name() !== "random") {
     console.error(`Input for output form "${outputFormat.name()}" must be random.`);
-    process.exit(1);
+    throw new Error("Invalid input format for non-round-trippable output format");
   }
 
   // Process input
@@ -221,7 +241,10 @@ async function main(): Promise<void> {
   console.log(output);
 }
 
-main().catch((error) => {
-  console.error(error.message);
+try {
+  main();
+} catch (error: unknown) {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(message);
   process.exit(1);
-});
+}

package/src/random.ts

@@ -3,8 +3,8 @@
  * Ported from seedtool-cli-rust/src/random.rs
  */
 
-import { sha256 } from "@noble/hashes/sha256";
-import { hkdf } from "@noble/hashes/hkdf";
+import { sha256 } from "@noble/hashes/sha2.js";
+import { hkdf } from "@noble/hashes/hkdf.js";
 
 /** SHA256 output size in bytes */
 const SHA256_SIZE = 32;
@@ -17,7 +17,7 @@ const SHA256_SIZE = 32;
  * from a seed, with an incrementing salt for each call.
  */
 export class DeterministicRandomNumberGenerator {
-  private seed: Uint8Array;
+  private readonly seed: Uint8Array;
   private salt: bigint;
 
   /**

package/src/seed.ts

@@ -11,17 +11,17 @@
 import { Envelope } from "@bcts/envelope";
 import { Seed as ComponentsSeed } from "@bcts/components";
 import { NAME, NOTE, DATE, SEED_TYPE } from "@bcts/known-values";
-import { toByteString, CborDate } from "@bcts/dcbor";
+import { CborDate } from "@bcts/dcbor";
 
 /**
  * Seed with optional metadata.
  * Matches Rust Seed struct in seed.rs.
  */
 export class Seed {
-  private _data: Uint8Array;
+  private readonly _data: Uint8Array;
   private _name: string;
   private _note: string;
-  private _creationDate?: Date;
+  private _creationDate: Date | undefined;
 
   /**
    * Create a new Seed with the given data.
@@ -144,7 +144,7 @@ export class Seed {
    */
   toEnvelope(): Envelope {
     // Create envelope with seed data as byte string subject
-    let envelope = Envelope.new(toByteString(this._data));
+    let envelope = Envelope.new(this._data);
 
     // Add type assertion
     envelope = envelope.addType(SEED_TYPE);

package/src/styles.ts

@@ -45,6 +45,6 @@ export const styles = {
  * Get styles object for use with commander.js
  * Note: Commander uses different styling API than clap
  */
-export function getStyles() {
+export function getStyles(): typeof styles {
   return styles;
 }