sec-ry 1.1.5

package/dist/cmd/denc.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedArgs } from "../lib/args";
+export declare function cmdDenc(parsed: ParsedArgs): void;

package/dist/cmd/denc.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cmdDenc = cmdDenc;
+const fs_1 = require("fs");
+const crypto_1 = require("../lib/crypto");
+const password_1 = require("../lib/password");
+const ui_1 = require("../lib/ui");
+const clip_1 = require("../lib/clip");
+const rc_1 = require("../lib/rc");
+const history_1 = require("../lib/history");
+const args_1 = require("../lib/args");
+function cmdDenc(parsed) {
+    const rc = (0, rc_1.loadRC)();
+    const token = parsed.positional[0];
+    if (!token)
+        (0, ui_1.err)("missing <token> argument");
+    if (token.startsWith("secry$") || token.startsWith("sec$")) {
+        (0, ui_1.err)("token uses '$' separator — did you use double quotes?\n     use single quotes:  secry denc 'secry:v2:...' -sw password", 2);
+    }
+    const rawPw = (0, args_1.getFlag)(parsed.flags, "sw") ?? rc.password;
+    if (!rawPw)
+        (0, ui_1.err)("-sw <password> is required (or set 'password' in .secryrc)");
+    const password = (0, password_1.resolvePassword)(rawPw);
+    const pwSource = (0, password_1.describePasswordSource)(rawPw);
+    const outFile = (0, args_1.getFlag)(parsed.flags, "out", "o");
+    const useClip = (0, args_1.hasFlag)(parsed.flags, "clip") || !!rc.clip;
+    const t0 = Date.now();
+    let result;
+    try {
+        result = (0, crypto_1.decrypt)(token, password);
+    }
+    catch (ex) {
+        const code = ex.code ?? "";
+        if (code === "ERR_EXPIRED")
+            (0, ui_1.err)(`token expired at ${ex.expiredAt?.toISOString()}`, 2);
+        if (code === "ERR_AUTH")
+            (0, ui_1.err)("wrong password or token has been tampered with", 2);
+        if (code === "ERR_FORMAT")
+            (0, ui_1.err)("value does not look like a secry or sec token", 2);
+        if (code === "ERR_MALFORMED")
+            (0, ui_1.err)("token is malformed or truncated", 2);
+        (0, ui_1.err)(ex.message, 2);
+    }
+    const elapsed = Date.now() - t0;
+    (0, history_1.recordHistory)("denc", token);
+    (0, ui_1.section)("decrypt");
+    (0, ui_1.box)([
+        { label: "token", value: token.length > 40 ? token.slice(0, 40) + "…" : token },
+        { label: "pw", value: pwSource },
+        { label: "algo", value: result.tokenVersion === 2 ? "ChaCha20-Poly1305" : "AES-256-GCM" },
+        ...(result.expiresAt ? [{ label: "expires", value: result.expiresAt.toISOString() }] : []),
+        { label: "result", value: result.plaintext.length > 52 ? result.plaintext.slice(0, 52) + "…" : result.plaintext },
+    ]);
+    (0, ui_1.ms)(elapsed);
+    if (outFile) {
+        try {
+            (0, fs_1.writeFileSync)(outFile, result.plaintext, "utf8");
+            (0, ui_1.info)(`saved to ${outFile}`);
+            process.stderr.write("\n");
+        }
+        catch {
+            (0, ui_1.err)(`could not write file: ${outFile}`, 2);
+        }
+    }
+    if (useClip) {
+        const copied = (0, clip_1.copyToClipboard)(result.plaintext);
+        if (copied)
+            (0, ui_1.info)("copied to clipboard");
+        else
+            (0, ui_1.warn)("--clip: no clipboard tool found");
+    }
+    if (!outFile)
+        (0, ui_1.data)(result.plaintext);
+}

package/dist/cmd/enc.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedArgs } from "../lib/args";
+export declare function cmdEnc(parsed: ParsedArgs): Promise<void>;

package/dist/cmd/enc.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cmdEnc = cmdEnc;
+const fs_1 = require("fs");
+const readline_1 = require("readline");
+const crypto_1 = require("../lib/crypto");
+const password_1 = require("../lib/password");
+const ui_1 = require("../lib/ui");
+const clip_1 = require("../lib/clip");
+const rc_1 = require("../lib/rc");
+const history_1 = require("../lib/history");
+const env_1 = require("../lib/env");
+const args_1 = require("../lib/args");
+const _MAX = 20 * 1024 * 1024;
+const _WARN = 5 * 1024 * 1024;
+const _NO_PW = "__secry_nopassword__";
+const _ALGO_LABEL = {
+    1: "AES-256-GCM / scrypt",
+    2: "ChaCha20-Poly1305 / scrypt",
+    3: "AES-256-CBC / scrypt",
+};
+function _detectEncoding(buf) {
+    if (buf[0] === 0xff && buf[1] === 0xfe)
+        return "utf16le";
+    if (buf[0] === 0xfe && buf[1] === 0xff)
+        return "utf16le";
+    if (buf[0] === 0xef && buf[1] === 0xbb && buf[2] === 0xbf)
+        return "utf8";
+    try {
+        const str = buf.toString("utf8");
+        if (Buffer.from(str, "utf8").equals(buf))
+            return "utf8";
+    }
+    catch { }
+    return "latin1";
+}
+function _readFileText(path) {
+    const buf = (0, fs_1.readFileSync)(path);
+    const encoding = _detectEncoding(buf);
+    const start = (encoding === "utf8" && buf[0] === 0xef) ? 3
+        : (encoding === "utf16le") ? 2
+            : 0;
+    const text = buf.subarray(start).toString(encoding);
+    return { text, encoding };
+}
+async function _confirm(msg) {
+    return new Promise((res) => {
+        const rl = (0, readline_1.createInterface)({ input: process.stdin, output: process.stderr });
+        rl.question(msg, (a) => { rl.close(); res(a.trim().toLowerCase() === "y"); });
+    });
+}
+async function _askPassword() {
+    return new Promise((res) => {
+        process.stderr.write(`  \x1b[36m?\x1b[0m  password: `);
+        process.stdin.setRawMode?.(true);
+        let buf = "";
+        process.stdin.resume();
+        process.stdin.setEncoding("utf8");
+        const onData = (ch) => {
+            if (ch === "\r" || ch === "\n") {
+                process.stdin.setRawMode?.(false);
+                process.stdin.pause();
+                process.stdin.removeListener("data", onData);
+                process.stderr.write("\n");
+                res(buf);
+            }
+            else if (ch === "\u0003") {
+                process.stderr.write("\naborted.\n");
+                process.exit(0);
+            }
+            else if (ch === "\u007f") {
+                buf = buf.slice(0, -1);
+            }
+            else {
+                buf += ch;
+            }
+        };
+        process.stdin.on("data", onData);
+    });
+}
+async function _interactive() {
+    return new Promise((resolve) => {
+        process.stderr.write(`  \x1b[36m?\x1b[0m  enter text: `);
+        let text = "";
+        if (env_1.env.hasRawMode) {
+            process.stdin.setRawMode(true);
+            process.stdin.resume();
+            process.stdin.setEncoding("utf8");
+            const onData = (ch) => {
+                if (ch === "\r" || ch === "\n") {
+                    process.stdin.setRawMode(false);
+                    process.stdin.pause();
+                    process.stdin.removeListener("data", onData);
+                    process.stderr.write("\n");
+                    resolve(text);
+                }
+                else if (ch === "\u0003") {
+                    process.stderr.write("\naborted.\n");
+                    process.exit(0);
+                }
+                else if (ch === "\u007f") {
+                    text = text.slice(0, -1);
+                    process.stderr.write("\b \b");
+                }
+                else {
+                    text += ch;
+                    process.stderr.write("·");
+                }
+            };
+            process.stdin.on("data", onData);
+        }
+        else {
+            const rl = (0, readline_1.createInterface)({ input: process.stdin, output: process.stderr });
+            rl.question("", (a) => { rl.close(); resolve(a); });
+        }
+    });
+}
+function _readInput(raw) {
+    if (raw.startsWith("@")) {
+        const path = raw.slice(1).trim();
+        if (!(0, fs_1.existsSync)(path))
+            (0, ui_1.err)(`file not found: ${path}`, 2);
+        const stat = (0, fs_1.statSync)(path);
+        if (stat.size > _MAX)
+            (0, ui_1.err)(`file too large: ${(stat.size / 1024 / 1024).toFixed(1)} MB. max 20 MB`, 2);
+        const { text, encoding } = _readFileText(path);
+        return { text, source: `file(${path})`, bytes: stat.size, encoding };
+    }
+    const bytes = Buffer.byteLength(raw, "utf8");
+    return { text: raw, source: "arg", bytes };
+}
+async function cmdEnc(parsed) {
+    const rc = (0, rc_1.loadRC)();
+    const rawPw = (0, args_1.getFlag)(parsed.flags, "sw") ?? rc.password;
+    let password;
+    let pwSource;
+    if (!rawPw) {
+        const proceed = await _confirm(`\n  \x1b[33m!\x1b[0m  Proceed without a password? [y/n]: `);
+        if (!proceed) {
+            password = await _askPassword();
+            if (password.length < 8)
+                (0, ui_1.warn)("password is short (< 8 chars). consider a stronger password.");
+            pwSource = "inline";
+        }
+        else {
+            password = _NO_PW;
+            pwSource = "none";
+        }
+    }
+    else {
+        password = (0, password_1.resolvePassword)(rawPw);
+        pwSource = (0, password_1.describePasswordSource)(rawPw);
+        if (password.length < 8)
+            (0, ui_1.warn)("password is short (< 8 chars). consider a stronger password.");
+    }
+    const useV2 = (0, args_1.hasFlag)(parsed.flags, "v2");
+    const useV3 = (0, args_1.hasFlag)(parsed.flags, "v3");
+    const version = useV3 ? 3 : useV2 ? 2 : 2;
+    const compact = (0, args_1.hasFlag)(parsed.flags, "compact");
+    let text;
+    let source;
+    let bytes;
+    let encoding;
+    const rawInput = parsed.positional[0];
+    if (!rawInput) {
+        text = await _interactive();
+        source = "interactive";
+        bytes = Buffer.byteLength(text, "utf8");
+    }
+    else {
+        const r = _readInput(rawInput);
+        text = r.text;
+        source = r.source;
+        bytes = r.bytes;
+        encoding = r.encoding;
+    }
+    if (encoding && encoding !== "utf8") {
+        (0, ui_1.warn)(`file encoding detected: ${encoding} — converted to UTF-8 before encrypting`);
+    }
+    const mb = bytes / 1024 / 1024;
+    if (bytes > _WARN) {
+        let msg = `\n  input is ${mb.toFixed(1)} MB. may be slow.\n`;
+        if (env_1.env.isTermux)
+            msg += "  warning: files above 500 MB may crash Termux.\n";
+        msg += "  continue? [y/N] ";
+        if (!await _confirm(msg)) {
+            process.stderr.write("aborted.\n");
+            process.exit(0);
+        }
+    }
+    const rawExp = (0, args_1.getFlag)(parsed.flags, "expires");
+    const expiresMs = rawExp ? (0, crypto_1.parseExpiry)(rawExp) : undefined;
+    const useClip = (0, args_1.hasFlag)(parsed.flags, "clip") || !!rc.clip;
+    const sizeLabel = mb < 0.01 ? `${bytes} B` : `${mb.toFixed(2)} MB`;
+    const t0 = Date.now();
+    let tok;
+    try {
+        tok = (0, crypto_1.encrypt)(text, password, { expiresMs }, version, compact);
+    }
+    catch (ex) {
+        (0, ui_1.err)(ex.message, 2);
+    }
+    const elapsed = Date.now() - t0;
+    (0, history_1.recordHistory)("enc", tok);
+    (0, ui_1.section)("encrypt");
+    (0, ui_1.box)([
+        { label: "input", value: source === "interactive" ? "(hidden)" : source === "arg" ? (text.length > 52 ? text.slice(0, 52) + "…" : text) : source },
+        { label: "size", value: sizeLabel },
+        { label: "encoding", value: encoding ?? "utf-8" },
+        { label: "pw", value: pwSource },
+        { label: "algo", value: _ALGO_LABEL[version] },
+        ...(compact ? [{ label: "mode", value: "compact  (sec: prefix)" }] : []),
+        ...(expiresMs ? [{ label: "expires", value: new Date(expiresMs).toISOString() }] : []),
+    ]);
+    (0, ui_1.token)(tok);
+    (0, ui_1.ms)(elapsed);
+    if (useClip) {
+        const copied = (0, clip_1.copyToClipboard)(tok);
+        if (copied)
+            (0, ui_1.info)("copied to clipboard");
+        else
+            (0, ui_1.warn)("--clip: no clipboard tool found");
+    }
+    process.stdout.write(tok + "\n");
+}

package/dist/cmd/example.d.ts

@@ -0,0 +1 @@
+export declare function cmdExample(): void;

package/dist/cmd/example.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cmdExample = cmdExample;
+const ui_1 = require("../lib/ui");
+const _NC = process.env.NO_COLOR !== undefined;
+const _c = _NC ? {
+    r: "", dim: "", bold: "", hi: "", cyan: "", gray: ""
+} : {
+    r: "\x1b[0m",
+    dim: "\x1b[2m",
+    bold: "\x1b[1m",
+    hi: "\x1b[38;5;252m",
+    cyan: "\x1b[36m",
+    gray: "\x1b[38;5;245m",
+};
+function _ui(s) { process.stderr.write(s); }
+function _visLen(s) {
+    return s.replace(/\x1b\[[0-9;]*m/g, "").length;
+}
+function _codeBox(title, lines) {
+    const lw = Math.max(...lines.map(([l]) => l.length));
+    const rows = lines.map(([label, val]) => {
+        const pad = " ".repeat(lw - label.length + 1);
+        const lc = label.startsWith("#") || label === "" ? _c.gray : _c.cyan;
+        const vc = label.startsWith("#") || label === "" ? _c.dim : _c.hi;
+        return `${lc}${label}${_c.r}${pad}${vc}${val}${_c.r}`;
+    });
+    const width = Math.max(...rows.map(_visLen), title.length + 4) + 4;
+    const hline = (l, r) => `${_c.gray}${l}${"─".repeat(width - 2)}${r}${_c.r}\n`;
+    _ui(`\n  ${_c.dim}${title}${_c.r}\n`);
+    _ui(hline("┌", "┐"));
+    for (const row of rows) {
+        const pad = Math.max(0, width - _visLen(row) - 2);
+        _ui(`${_c.gray}│${_c.r} ${row}${" ".repeat(pad)} ${_c.gray}│${_c.r}\n`);
+    }
+    _ui(hline("└", "┘"));
+}
+function cmdExample() {
+    _ui(`\n${_c.gray}${"─".repeat(48)}${_c.r}\n`);
+    _ui(`  ${_c.bold}${_c.cyan}${ui_1.PKG}${_c.r}  ${_c.gray}v${ui_1.VERSION}  examples${_c.r}\n`);
+    _ui(`${_c.gray}${"─".repeat(48)}${_c.r}\n`);
+    _codeBox("cli", [
+        ["# encrypt", ""],
+        [`${ui_1.BIN} enc`, `'my secret'  -sw mypassword`],
+        [`${ui_1.BIN} enc`, `'expires in 1h'  -sw mypassword  --expires 1h`],
+        [`${ui_1.BIN} enc`, `@notes.txt  -sw mypassword`],
+        ["", ""],
+        ["# decrypt", ""],
+        [`${ui_1.BIN} denc`, `'secry:v2:...'  -sw mypassword`],
+        [`${ui_1.BIN} denc`, `'secry:v2:...'  -sw mypassword  --out result.txt`],
+        ["", ""],
+        ["# generate password", ""],
+        [`${ui_1.BIN} gen`, `32`],
+        ["", ""],
+        ["# verify", ""],
+        [`${ui_1.BIN} verify`, `'secry:v2:...'  -sw mypassword`],
+        ["", ""],
+        ["# quiet mode  (token only)", ""],
+        [`${ui_1.BIN} enc`, `'my secret'  -sw mypassword  --quiet`],
+        ["", ""],
+        ["# capture token in variable", ""],
+        [`TOKEN=$(${ui_1.BIN} enc`, `'text'  -sw mypassword  --quiet)`],
+        [`${ui_1.BIN} denc`, `"$TOKEN"  -sw mypassword`],
+    ]);
+    _codeBox("library  (node.js)", [
+        ["# install", ""],
+        ["npm install", "secry"],
+        ["", ""],
+        ["import secry", "from 'secry'"],
+        ["", ""],
+        ["# generate password", ""],
+        ["const pw", "= secry.generate(32)"],
+        ["", ""],
+        ["# encrypt", ""],
+        ["const token", "= secry.encrypt('my secret', pw)"],
+        ["const token", "= secry.encrypt('expires', pw, { expiresMs: Date.now() + 3600_000 })"],
+        ["", ""],
+        ["# decrypt", ""],
+        ["const text", "= secry.decrypt(token).key(pw)"],
+        ["", ""],
+        ["# verify", ""],
+        ["const ok", "= secry.verify(token, pw)"],
+        ["", ""],
+        ["# fingerprint", ""],
+        ["const fp", "= secry.fingerprint('hello', 'secret')"],
+        ["", ""],
+        ["# inspect token", ""],
+        ["const meta", "= secry.inspect(token)"],
+        ["// meta", "{ version, algo, saltHex, nonceHex, payloadBytes }"],
+    ]);
+    _ui(`\n${_c.gray}${"─".repeat(48)}${_c.r}\n\n`);
+}

package/dist/cmd/fp.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedArgs } from "../lib/args";
+export declare function cmdFp(parsed: ParsedArgs): void;

package/dist/cmd/fp.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cmdFp = cmdFp;
+const crypto_1 = require("../lib/crypto");
+const password_1 = require("../lib/password");
+const ui_1 = require("../lib/ui");
+const rc_1 = require("../lib/rc");
+const args_1 = require("../lib/args");
+function cmdFp(parsed) {
+    const rc = (0, rc_1.loadRC)();
+    const text = parsed.positional[0];
+    if (!text)
+        (0, ui_1.err)("missing <text> argument");
+    const rawPw = (0, args_1.getFlag)(parsed.flags, "sw") ?? rc.password;
+    if (!rawPw)
+        (0, ui_1.err)("-sw <secret> is required");
+    const secret = (0, password_1.resolvePassword)(rawPw);
+    const t0 = Date.now();
+    const fp = (0, crypto_1.hmacFingerprint)(text, secret);
+    const elapsed = Date.now() - t0;
+    (0, ui_1.section)("fingerprint");
+    (0, ui_1.box)([
+        { label: "input", value: text.length > 52 ? text.slice(0, 52) + "…" : text },
+        { label: "algo", value: "HMAC-SHA256" },
+        { label: "fp", value: fp },
+    ]);
+    (0, ui_1.ms)(elapsed);
+    (0, ui_1.data)(fp);
+}

package/dist/cmd/gen.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedArgs } from "../lib/args";
+export declare function cmdGen(parsed: ParsedArgs): void;

package/dist/cmd/gen.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cmdGen = cmdGen;
+const crypto_1 = require("crypto");
+const ui_1 = require("../lib/ui");
+const clip_1 = require("../lib/clip");
+const rc_1 = require("../lib/rc");
+const args_1 = require("../lib/args");
+const _B64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+function _gen(bytes, upper) {
+    const raw = (0, crypto_1.randomBytes)(bytes);
+    let pw = "";
+    for (const b of raw)
+        pw += _B64[b % 64];
+    if (upper && !/[A-Z]/.test(pw)) {
+        const i = Math.floor(Math.random() * pw.length);
+        pw = pw.slice(0, i) + pw[i].toUpperCase() + pw.slice(i + 1);
+    }
+    return pw;
+}
+function _entropy(bytes) {
+    const bits = Math.floor(bytes * 5.954);
+    if (bits >= 256)
+        return `${bits} bits  — extreme`;
+    if (bits >= 128)
+        return `${bits} bits  — very strong`;
+    if (bits >= 80)
+        return `${bits} bits  — strong`;
+    if (bits >= 60)
+        return `${bits} bits  — good`;
+    return `${bits} bits  — weak`;
+}
+function cmdGen(parsed) {
+    const rc = (0, rc_1.loadRC)();
+    const raw = parsed.positional[0];
+    const bytes = raw ? parseInt(raw, 10) : (rc.bytes ?? 24);
+    const useClip = (0, args_1.hasFlag)(parsed.flags, "clip") || !!rc.clip;
+    const upper = (0, args_1.hasFlag)(parsed.flags, "upper");
+    const rawCount = (0, args_1.getFlag)(parsed.flags, "count");
+    const count = rawCount ? parseInt(rawCount, 10) : 1;
+    if (isNaN(bytes) || bytes < 8 || bytes > 256)
+        (0, ui_1.err)("bytes must be between 8 and 256");
+    if (isNaN(count) || count < 1 || count > 20)
+        (0, ui_1.err)("--count must be between 1 and 20");
+    const t0 = Date.now();
+    const passwords = Array.from({ length: count }, () => _gen(bytes, upper));
+    const elapsed = Date.now() - t0;
+    (0, ui_1.section)("generate password");
+    if (count === 1) {
+        (0, ui_1.box)([
+            { label: "bytes", value: String(bytes) },
+            { label: "entropy", value: _entropy(bytes) },
+            { label: "upper", value: upper ? "yes" : "no" },
+            { label: "pw", value: passwords[0] },
+        ]);
+    }
+    else {
+        (0, ui_1.box)([
+            { label: "bytes", value: String(bytes) },
+            { label: "entropy", value: _entropy(bytes) },
+            { label: "upper", value: upper ? "yes" : "no" },
+            { label: "count", value: String(count) },
+            ...passwords.map((pw, i) => ({ label: `pw ${i + 1}`, value: pw })),
+        ]);
+    }
+    (0, ui_1.ms)(elapsed);
+    if (useClip) {
+        const copied = (0, clip_1.copyToClipboard)(passwords[0]);
+        if (copied)
+            (0, ui_1.info)("copied to clipboard  (pw 1)");
+        else
+            (0, ui_1.warn)("--clip: no clipboard tool found");
+        process.stderr.write("\n");
+    }
+    passwords.forEach((pw) => (0, ui_1.data)(pw));
+}

package/dist/cmd/history.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedArgs } from "../lib/args";
+export declare function cmdHistory(parsed: ParsedArgs): void;

package/dist/cmd/history.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cmdHistory = cmdHistory;
+const history_1 = require("../lib/history");
+const ui_1 = require("../lib/ui");
+const args_1 = require("../lib/args");
+function cmdHistory(parsed) {
+    if ((0, args_1.hasFlag)(parsed.flags, "clear")) {
+        (0, history_1.clearHistory)();
+        (0, ui_1.ok)("history cleared");
+        process.stderr.write("\n");
+        return;
+    }
+    const entries = (0, history_1.getHistory)();
+    if (entries.length === 0) {
+        (0, ui_1.warn)("no history yet\n");
+        return;
+    }
+    (0, ui_1.section)("history");
+    (0, ui_1.box)(entries.map((e) => ({
+        label: new Date(e.ts).toISOString().slice(0, 19).replace("T", " "),
+        value: `${e.cmd.padEnd(5)}  fp:${e.fp}`,
+    })));
+    process.stderr.write("\n");
+}

package/dist/cmd/info.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedArgs } from "../lib/args";
+export declare function cmdInfo(parsed: ParsedArgs): void;

package/dist/cmd/info.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cmdInfo = cmdInfo;
+const crypto_1 = require("../lib/crypto");
+const ui_1 = require("../lib/ui");
+function cmdInfo(parsed) {
+    const token = parsed.positional[0];
+    if (!token)
+        (0, ui_1.err)("missing <token> argument");
+    let meta;
+    try {
+        meta = (0, crypto_1.inspectToken)(token);
+    }
+    catch (ex) {
+        (0, ui_1.err)(ex.message, 2);
+    }
+    (0, ui_1.section)("token info");
+    (0, ui_1.box)([
+        { label: "prefix", value: meta.prefix },
+        { label: "version", value: meta.version },
+        { label: "algo", value: meta.algo },
+        { label: "kdf", value: "scrypt (N=16384, r=8, p=1)" },
+        { label: "salt", value: meta.saltHex },
+        { label: "nonce", value: meta.nonceHex },
+        { label: "bytes", value: `${meta.payloadBytes} (raw payload)` },
+    ]);
+    process.stderr.write("\n");
+}

package/dist/cmd/root.d.ts

@@ -0,0 +1 @@
+export declare function cmdRoot(): Promise<void>;