@inversealtruism/cairn-cli 0.3.2 → 0.3.6

package/dist/lib/api.js

@@ -64,11 +64,73 @@ export async function pickInput(addr, minValue) {
     const x = cand[0] ?? (j.utxos ?? []).find(ok);
     return x ? { input: `${x.txid}:${Number(x.vout)}:${Number(x.value)}`, value: Number(x.value) } : null;
 }
+// UTXO-VALUE-1 cross-source check. cairn-cli has no codec to recompute an input's REAL value, so
+// a hostile/MITM'd CAIRN_API that UNDER-reports a UTXO's value would make `csd` compute too-small
+// a change and silently burn the difference as fee. If the user has configured an INDEPENDENT node
+// (CAIRN_RPC, a different host than the proxy), confirm the picked outpoint's value against its
+// authoritative UTXO set and refuse on a mismatch. Returns:
+//   { checked:false }                          — no independent RPC configured / unreachable (caller warns + relies on the fee cap)
+//   { checked:true, ok:true,  value }          — independent node agrees (display the verified value)
+//   { checked:true, ok:false, value }          — DISAGREEMENT (hostile proxy) → caller refuses
+//   { checked:true, ok:false, missing:true }   — outpoint absent on the independent node → suspicious, caller refuses
+export async function verifyInputValue(addr, txid, vout, claimedValue) {
+    if (!CAIRN_RPC)
+        return { checked: false };
+    if (!/^0x[0-9a-fA-F]{40}$/.test(addr) || !HEX64.test(txid))
+        return { checked: false };
+    let j;
+    try {
+        const r = await fetch(`${CAIRN_RPC}/utxos/${encodeURIComponent(addr)}`, { redirect: "error", signal: AbortSignal.timeout(6000) });
+        if (!r.ok)
+            return { checked: false };
+        j = await r.json();
+    }
+    catch {
+        return { checked: false };
+    }
+    const list = j.utxos ?? j.outputs ?? [];
+    const norm = (t) => String(t).toLowerCase().replace(/^0x/, "");
+    const hit = list.find((u) => norm(u.txid) === norm(txid) && Number(u.vout) === vout);
+    if (!hit)
+        return { checked: true, ok: false, missing: true };
+    const v = Number(hit.value);
+    return { checked: true, ok: Number.isSafeInteger(v) && v === claimedValue, value: v };
+}
 export async function confirmedBalance(addr) {
     const j = await req(`/api/rpc/utxos-all/${encodeURIComponent(addr)}`);
     return { balance: Number(j.confirmed_balance ?? 0), utxos: (j.utxos ?? []).length };
 }
 export async function tipHeight() { return Number((await req("/api/rpc/tip")).height ?? 0); }
+// Chain-view freshness of the proxy's backend node: { stale, secondsSinceAdvance, staleSecsThreshold, height }.
+// Used to refuse building a tx against a frozen/forked tip. Throws if the surface is unreachable
+// (caller treats that as a soft warning, never a hard block — matches the 'cannot reach' UX).
+export async function rpcStatus() {
+    return req("/api/rpc/status");
+}
+// Look up a tx by id on the node. Mined txs resolve to { ok:true, txid, block_hash, height };
+// an unknown id resolves to { ok:false, err:"not found" }. (The node's /tx indexes MINED txs;
+// a mempool-only tx returns not-found, so a not-found is "no proof yet", never "rejected".)
+export async function txStatus(txid) {
+    if (!/^0x[0-9a-fA-F]{64}$/.test(txid))
+        return { ok: false }; // never splice an unshaped id into the URL
+    const j = await req(`/api/rpc/tx/${encodeURIComponent(txid)}`).catch(() => null);
+    return j ?? { ok: false };
+}
+// Has the node confirmed OUR exact txid (mined into the chain)? Polls a few times because a
+// freshly-submitted tx is mempool-only until a block lands. Returns true ONLY on an exact
+// txid match the node reports as known — evidence the user's own tx (not a different conflict)
+// is on-chain. (Non-fatal on an unreachable node: simply never confirms.) The poll budget is
+// overridable via CAIRN_CONFIRM_ATTEMPTS / CAIRN_CONFIRM_INTERVAL_MS (used by the test suite).
+export async function confirmTxMined(txid, attempts = Number(process.env.CAIRN_CONFIRM_ATTEMPTS) || 4, intervalMs = Number(process.env.CAIRN_CONFIRM_INTERVAL_MS) || 7000) {
+    for (let i = 0; i < attempts; i++) {
+        const s = await txStatus(txid).catch(() => null);
+        if (s?.ok && typeof s.txid === "string" && s.txid.toLowerCase() === txid.toLowerCase())
+            return true;
+        if (i < attempts - 1)
+            await new Promise((res) => setTimeout(res, intervalMs));
+    }
+    return false;
+}
 // Submit a node-JSON tx through the proxy (for `csd spend`, which builds+signs but doesn't
 // reliably submit to a proxy URL). Returns the node's response.
 export async function submitTx(txNodeJson) { return req("/api/rpc/tx/submit", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ tx: txNodeJson }) }); }
@@ -99,6 +161,28 @@ export async function registerRawContent(bytes, txid, attempts = 20) {
     }
     return false;
 }
+// Independent confirmation (audit H-7): is this txid mined according to CAIRN_RPC, a node on a
+// DIFFERENT host than the proxy? `confirmTxMined` above polls the proxy's own /api/rpc/tx, which a
+// hostile/MITM'd CAIRN_API can string-echo to forge a "mined" reply. This cross-checks an
+// independent node. Returns true (independent node confirms OUR exact txid mined), false (it does
+// not), or null (no independent RPC configured / unreachable → "unverifiable", never a hard claim).
+export async function chainTxMined(txid) {
+    if (!CAIRN_RPC)
+        return null;
+    if (!/^0x[0-9a-fA-F]{64}$/.test(txid))
+        return null;
+    try {
+        const r = await fetch(`${CAIRN_RPC}/tx/${encodeURIComponent(txid)}`, { redirect: "error", signal: AbortSignal.timeout(6000) });
+        if (!r.ok)
+            return null;
+        const j = await r.json();
+        const t = String(j.txid ?? j.tx?.txid ?? "").toLowerCase().replace(/^0x/, "");
+        return j.ok === true && t === txid.toLowerCase().replace(/^0x/, "");
+    }
+    catch {
+        return null;
+    }
+}
 // optional: query a raw csd node RPC (for trustless verify)
 export async function chainProposal(id) {
     if (!CAIRN_RPC)

package/dist/lib/cairnx.js

@@ -0,0 +1,110 @@
+// CairnX — the token + .csd-name layer that lives entirely in CSD Propose records on the
+// `cairnx:v1` domain. This file is the CLI's complete CairnX surface:
+//   • a READ client for the CairnX state API (resolution order: $CAIRNX_API → the local
+//     service → the public gateway, GET-only) with automatic fallback on network failure
+//   • the canonical TRANSFER record builder — canonicalised with the SAME @inversealtruism/csd-codec
+//     `canonicalJson` the resolver uses (single source of truth), so the CLI's on-chain payload_hash
+//     is byte-identical to the resolver's by construction (CLI-C7: was a hand-rolled stableStringify,
+//     proven byte-identical to canonicalJson for the transfer-record shape, now consolidated to remove
+//     the latent dual-canonicaliser seam).
+//   • exact human↔base-unit amount math as STRING/BigInt arithmetic — floats never touch
+//     token amounts (no "1.1 * 1e8 = 110000000.00000001" class of bug, no silent truncation).
+import { sha256Hex } from "./item.js";
+import { canonicalJson } from "@inversealtruism/csd-codec";
+export const CAIRNX_DOMAIN = "cairnx:v1";
+export const CAIRNX_ANCHOR_FEE = 25_000_000; // 0.25 CSD — the consensus min Propose fee that anchors a record
+export const MAX_AMOUNT = (1n << 96n) - 1n; // CONVENTION.md: token amounts are ≤ 96-bit
+const MAX_RECORD_BYTES = 512; // consensus MAX_URI_BYTES — the record must fit in `uri`
+// Validation shapes (mirrors CONVENTION.md §4 — kept in sync by the byte-exact fixtures).
+export const TICKER_RE = /^[A-Z][A-Z0-9]{2,11}$/;
+export const NAME_RE = /^[a-z0-9](?:[a-z0-9-]{0,30}[a-z0-9])?$/; // a claimable .csd name
+const ADDR_RE = /^0x[0-9a-f]{40}$/; // records carry LOWERCASE addresses
+export function buildTransferRecord(p) {
+    const to = String(p.to).toLowerCase();
+    if (!TICKER_RE.test(p.ticker))
+        throw new Error(`bad ticker "${p.ticker}" — want 3–12 chars [A-Z0-9], starting with a letter`);
+    if (!ADDR_RE.test(to))
+        throw new Error(`bad recipient "${p.to}" — want a 0x… 20-byte address`);
+    if (p.amount <= 0n)
+        throw new Error("amount must be > 0");
+    if (p.amount > MAX_AMOUNT)
+        throw new Error("amount exceeds the 96-bit token-amount limit");
+    const record = { amount: p.amount.toString(), t: "transfer", ticker: p.ticker, to, v: 1 };
+    const uri = canonicalJson(record);
+    if (Buffer.byteLength(uri, "utf8") > MAX_RECORD_BYTES)
+        throw new Error("record exceeds 512 bytes"); // unreachable for a transfer, kept as a guard
+    return { record, uri, payloadHash: sha256Hex(uri) };
+}
+// ── exact amount math (strings + BigInt only) ─────────────────────────────────────────────
+// "1.5" with decimals 8 → 150000000n. Fails LOUDLY instead of truncating: "1.5" on a
+// 0-decimals token is an error, not 1. Trailing fractional zeros are exact and accepted
+// ("1.50" @ 1 decimal → 15n).
+export function humanToBase(human, decimals) {
+    if (!Number.isInteger(decimals) || decimals < 0 || decimals > 8)
+        throw new Error(`bad token decimals ${decimals}`);
+    const s = String(human).trim();
+    if (s.length === 0 || s.length > 40)
+        throw new Error(`bad amount "${human}"`); // MAX_AMOUNT is 29 digits; cap before BigInt
+    const m = /^([0-9]+)?(?:\.([0-9]+))?$/.exec(s);
+    if (!m || (m[1] === undefined && m[2] === undefined))
+        throw new Error(`bad amount "${human}" — use plain digits like 1 or 1.25`);
+    const frac = (m[2] ?? "").replace(/0+$/, ""); // trailing zeros are exactly representable — drop them
+    if (frac.length > decimals)
+        throw new Error(`amount "${human}" has more decimal places than this token allows (${decimals})`);
+    const base = BigInt(m[1] ?? "0") * 10n ** BigInt(decimals) + BigInt(frac.padEnd(decimals, "0") || "0");
+    if (base > MAX_AMOUNT)
+        throw new Error(`amount "${human}" exceeds the 96-bit token-amount limit`);
+    return base;
+}
+// 150000000n @ 8 → "1.5" (exact inverse of humanToBase; no grouping — display adds that).
+export function baseToHuman(base, decimals) {
+    if (!Number.isInteger(decimals) || decimals < 0 || decimals > 8)
+        throw new Error(`bad token decimals ${decimals}`);
+    const v = typeof base === "bigint" ? base : BigInt(String(base));
+    if (v < 0n)
+        throw new Error("negative token amount");
+    const s = v.toString().padStart(decimals + 1, "0");
+    const int = decimals ? s.slice(0, -decimals) : s;
+    const fr = decimals ? s.slice(-decimals).replace(/0+$/, "") : "";
+    return fr ? `${int}.${fr}` : int;
+}
+// ── read API client (GET-only; never sees a key) ──────────────────────────────────────────
+// Base resolution order: $CAIRNX_API (explicit choice — used exclusively), else the local
+// CairnX service, else the public gateway. Read at call time (not import) so tests can vary it.
+export function defaultBases() {
+    const env = (process.env.CAIRNX_API ?? "").trim().replace(/\/+$/, "");
+    if (env)
+        return [env];
+    return ["http://127.0.0.1:8794/cairnx", "https://cairn-substrate.com/trade/api/cairnx"];
+}
+// Remember the first base that answered (per base-list) so one command's N requests don't
+// re-probe a dead localhost N times.
+let active = null;
+export const activeCairnxBase = () => active?.base ?? null;
+export async function cairnxGet(path, bases = defaultBases()) {
+    const key = bases.join(" ");
+    const order = active?.key === key && bases.includes(active.base)
+        ? [active.base, ...bases.filter((b) => b !== active.base)] : bases;
+    let lastErr = null;
+    for (const base of order) {
+        let res;
+        try {
+            res = await fetch(`${base}${path}`, { signal: AbortSignal.timeout(8000) }); // GET-only, no credentials — redirects are safe to follow
+        }
+        catch (e) {
+            lastErr = e;
+            continue;
+        } // network failure → try the next base
+        // A reachable base's answer is authoritative — an HTTP 404 here is a real "not found",
+        // never a reason to fall through to a different (possibly divergent) view of state.
+        active = { key, base };
+        if (!res.ok) {
+            const j = await res.json().catch(() => null);
+            const e = new Error(j?.error ? String(j.error) : `CairnX API ${path} → HTTP ${res.status}`);
+            e.status = res.status;
+            throw e;
+        }
+        return res.json();
+    }
+    throw new Error(`cannot reach a CairnX API (tried ${bases.join(", ")}) — set CAIRNX_API (${lastErr?.message ?? lastErr})`);
+}

package/dist/lib/config.js

@@ -1,7 +1,7 @@
 // cairn-cli configuration (env-overridable).
 import { homedir } from "node:os";
 import { join, dirname } from "node:path";
-import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { readFileSync, writeFileSync, mkdirSync, chmodSync } from "node:fs";
 export const CAIRN_API = (process.env.CAIRN_API ?? "https://cairn-substrate.com").replace(/\/+$/, "");
 export const CAIRN_TOKEN = process.env.CAIRN_TOKEN ?? ""; // optional operator write token (falls back to local csd wallet)
 export const CAIRN_RPC = process.env.CAIRN_RPC ?? ""; // optional: a csd node RPC, enables trustless verify
@@ -13,7 +13,9 @@ export const MIN_FEE_ATTEST = 5_000_000; // 0.05 CSD
 export function csdToCoins(base) {
     return (base / CSD_PER_COIN).toLocaleString(undefined, { maximumFractionDigits: 4 });
 }
-// small local config: caches ONLY the user's public address (never a key).
+// small local config: caches ONLY the user's public address (never a key). Written with
+// owner-only perms (dir 0700, file 0600) so another local user can't poison the cached address
+// to redirect `cairn address` output (F13/R18 — the wallet is still the source of truth).
 const CFG_PATH = process.env.CAIRN_CLI_CONFIG ?? join(homedir(), ".config", "cairn-cli", "config.json");
 export function loadLocalConfig() { try {
     return JSON.parse(readFileSync(CFG_PATH, "utf8"));
@@ -21,10 +23,18 @@ export function loadLocalConfig() { try {
 catch {
     return {};
 } }
+// Returns true iff the address was durably persisted. CLI-C2: a SILENT failure here breaks the
+// H-2 "derive the key-on-argv address at most once" guarantee — a read-only HOME / unwritable
+// CAIRN_CLI_CONFIG / full disk would make every subsequent call re-derive (re-exposing the key on
+// the csd argv). Callers surface a warning on false so the user can fix the cache (or stop deriving).
 export function saveLocalConfig(patch) {
     try {
-        mkdirSync(dirname(CFG_PATH), { recursive: true });
-        writeFileSync(CFG_PATH, JSON.stringify({ ...loadLocalConfig(), ...patch }, null, 2) + "\n");
+        mkdirSync(dirname(CFG_PATH), { recursive: true, mode: 0o700 });
+        writeFileSync(CFG_PATH, JSON.stringify({ ...loadLocalConfig(), ...patch }, null, 2) + "\n", { mode: 0o600 });
+        chmodSync(CFG_PATH, 0o600); // tighten even if the file pre-existed (writeFileSync mode is create-only)
+        return true;
+    }
+    catch {
+        return false;
     }
-    catch { /* best-effort */ }
 }

package/dist/lib/csd.js

@@ -1,19 +1,140 @@
 // Thin wrapper around the user's INSTALLED `csd` CLI. cairn-cli never holds a private
 // key: for any write it shells out to `csd`, which signs with the user's own csd wallet
 // config key (CSD_SIG_V1). We only orchestrate — supply the input (fetched from the Cairn
-// proxy, so no local node is required) + the Cairn payload — and `csd` does the signing
-// and submit. Binary resolution: CAIRN_CSD env → `csd` on PATH → the substrate default.
+// proxy, so no local node is required) + the Cairn payload — and `csd` does the signing.
+//
+// SECURITY (audit H-1): which `csd` binary signs is a trust decision. A bare `csd` resolved
+// by $PATH order lets a malicious binary planted earlier on PATH (dev env, npm postinstall,
+// shared host) capture the wallet key the instant cairn shells out. So:
+//   • CAIRN_CSD, if set, is the user's EXPLICIT choice — honored, but MUST be absolute.
+//   • Otherwise we resolve `csd` from a list of CANONICAL absolute locations FIRST (not PATH
+//     order), fall back to a PATH search only if none exists, REFUSE a binary in a world-
+//     writable / transient / cwd location, and SURFACE the resolved absolute path so the user
+//     can see which binary signs.
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
+import { statSync, realpathSync } from "node:fs";
+import { isAbsolute, join, dirname, delimiter } from "node:path";
 const pexec = promisify(execFile);
+// Back-compat hint (the configured name/path); real resolution is resolveCsdBin().
 export const CSD_BIN = process.env.CAIRN_CSD || "csd";
+// Canonical absolute install locations, checked in order BEFORE any $PATH search so a binary
+// planted earlier on PATH cannot win.
+const HOME = process.env.HOME || "";
+const CANONICAL = [
+    "/usr/local/bin/csd", "/usr/bin/csd", "/opt/substrate_miner/bin/csd",
+    ...(HOME ? [join(HOME, ".cargo/bin/csd"), join(HOME, ".local/bin/csd")] : []),
+];
+// Is this resolved path attacker-plantable? Returns a human reason, or null if it looks safe.
+function insecureReason(abs) {
+    let st;
+    try {
+        st = statSync(abs);
+    }
+    catch {
+        return "does not exist";
+    }
+    if (!st.isFile())
+        return "is not a regular file";
+    if (st.mode & 0o002)
+        return "is world-writable";
+    const dir = dirname(abs);
+    try {
+        const dst = statSync(dir);
+        // CLI-C2-STICKY: a trusted signing binary must never live in a world-writable directory —
+        // the sticky bit stops OTHER users deleting your file, but the dir's owner (the attacker, if
+        // they own the planted binary) is unaffected, so do NOT exempt sticky 1777 dirs from the check.
+        if (dst.mode & 0o002)
+            return `is in a world-writable directory (${dir})`;
+    }
+    catch { /* dir unreadable — fall through */ }
+    if (dir === process.cwd())
+        return "is in the current working directory (a cwd hijack vector)";
+    if (dir.startsWith("/tmp") || dir.startsWith("/var/tmp") || dir.startsWith("/dev/shm"))
+        return `is in a transient directory (${dir})`;
+    return null;
+}
+function pathSearch(name) {
+    for (const d of (process.env.PATH || "").split(delimiter).filter(Boolean)) {
+        const p = join(d, name);
+        try {
+            const st = statSync(p);
+            if (st.isFile() && (st.mode & 0o111))
+                return p;
+        }
+        catch { /* keep looking */ }
+    }
+    return null;
+}
+let _resolved = null;
+// Resolve (and cache) the trusted `csd` path. See header for the policy.
+export function resolveCsdBin() {
+    if (_resolved)
+        return _resolved;
+    const env = process.env.CAIRN_CSD;
+    if (env) {
+        // Explicit user choice. Require absolute (a relative explicit path is still PATH/cwd-hijackable);
+        // honor it even in an unusual location (the user told us exactly which binary to trust), but warn
+        // if world-writable. We do NOT refuse here — the test harness and power users point CAIRN_CSD at
+        // bespoke absolute paths deliberately.
+        if (!isAbsolute(env))
+            return (_resolved = { path: null, explicit: true, error: `CAIRN_CSD must be an ABSOLUTE path (got "${env}") — a relative csd binary is a key-theft risk` });
+        let abs = env;
+        try {
+            abs = realpathSync(env);
+        }
+        catch { /* may legitimately not exist yet — surfaced at run/available */ }
+        // CLI-C2-EXPLICIT-DIR: warn (don't refuse — it's the user's explicit choice) on ANY insecurity
+        // of the resolved path, not just a world-writable FILE: a world-writable / transient / cwd
+        // DIRECTORY is just as plantable. "does not exist" is normal (surfaced later), so skip it.
+        let warning;
+        const reason = insecureReason(abs);
+        if (reason && reason !== "does not exist")
+            warning = `CAIRN_CSD (${abs}) ${reason} — anyone could replace it with a key-stealing binary`;
+        return (_resolved = { path: abs, explicit: true, warning });
+    }
+    // Implicit resolution: canonical locations first (defeats PATH-order hijack), then PATH.
+    for (const cand of CANONICAL) {
+        // CLI-C2-SYMLINK-TOCTOU: resolve the symlink FIRST, then run the security check on the REAL
+        // target (insecureReason on a symlink validates the link's parent dir, not the target's) — so a
+        // canonical-path symlink can't point at a world-writable binary that slips the check.
+        try {
+            const st = statSync(cand);
+            if (!st.isFile() || !(st.mode & 0o111))
+                continue;
+            const real = realpathSync(cand);
+            if (!insecureReason(real))
+                return (_resolved = { path: real, explicit: false });
+        }
+        catch { /* next */ }
+    }
+    const found = pathSearch("csd");
+    if (!found)
+        return (_resolved = { path: null, explicit: false, error: "`csd` not found in any trusted location or on PATH — install it, or set CAIRN_CSD to its absolute path" });
+    let abs;
+    try {
+        abs = realpathSync(found);
+    }
+    catch {
+        return (_resolved = { path: null, explicit: false, error: `csd at ${found} could not be resolved` });
+    }
+    const bad = insecureReason(abs);
+    if (bad)
+        return (_resolved = { path: null, explicit: false, error: `refusing to run csd at ${abs} — it ${bad}. A malicious csd there could steal your wallet key. Move it to a trusted location (e.g. /usr/local/bin) or set CAIRN_CSD to a trusted absolute path.` });
+    return (_resolved = { path: abs, explicit: false });
+}
+// For display (the `setup` command shows the user exactly which binary will sign).
+export function csdPathInfo() { return resolveCsdBin(); }
 function extractTxid(s) {
     const m = s.match(/txid["':\s]+0x([0-9a-fA-F]{64})/) || s.match(/0x[0-9a-fA-F]{64}/);
     return m ? (m[1] ? "0x" + m[1] : m[0]) : undefined;
 }
 export async function run(args) {
+    const bin = resolveCsdBin();
+    if (!bin.path)
+        return { ok: false, stdout: "", stderr: bin.error || "csd unavailable" };
     try {
-        const { stdout, stderr } = await pexec(CSD_BIN, args, { timeout: 30000 });
+        const { stdout, stderr } = await pexec(bin.path, args, { timeout: 30000 });
         return { ok: true, stdout, stderr, txid: extractTxid(stdout + stderr) };
     }
     catch (e) {
@@ -21,9 +142,10 @@ export async function run(args) {
         return { ok: false, stdout: e.stdout ?? "", stderr: e.stderr ?? String(e.message ?? e), txid: extractTxid(out) };
     }
 }
-// Is `csd` installed + runnable?
-export async function available() { try {
-    await pexec(CSD_BIN, ["--version"], { timeout: 5000 });
+// Is `csd` installed + runnable (at the trusted path)?
+export async function available() { const bin = resolveCsdBin(); if (!bin.path)
+    return false; try {
+    await pexec(bin.path, ["--version"], { timeout: 5000 });
     return true;
 }
 catch {
@@ -37,5 +159,10 @@ export async function walletConfig() { const r = await run(["wallet", "config"])
 catch {
     return null;
 } }
-// Derive the public addr20 from a privkey via `csd wallet recover` (local; key never networked).
+// Derive the public addr20 from a privkey via `csd wallet recover`.
+// SECURITY (audit H-2): this puts --privkey on the csd argv, briefly readable via /proc on a
+// shared host. It is a LAST resort — resolveAddr() only calls it when the wallet has no
+// default_change_addr20 AND we have no cached address, and the result is cached so it happens at
+// most once. Callers surface keyExposureWarning and recommend setting a change address.
 export async function deriveAddr(priv) { const r = await run(["wallet", "recover", "--privkey", priv]); const m = r.stdout.match(/addr20:\s*(0x[0-9a-fA-F]{40})/i); return m ? m[1] : null; }
+export const keyExposureWarning = "deriving your address from the wallet key briefly exposes it on the `csd` command line (readable via /proc on a shared host). Set a change address once — `csd wallet init --privkey <key>` — so cairn never needs the key again.";

package/dist/lib/ui.js

@@ -66,12 +66,17 @@ export function bar(value, max, width = 16) {
 export function csd(base) {
     return c.green(`${(base / 1e8).toLocaleString(undefined, { maximumFractionDigits: 4 })}`) + c.gray(" CSD");
 }
-// Strip C0/C1 control chars (incl. ESC) from UNTRUSTED strings before printing them to a
-// TTY, so a hostile server/chain field (title, body, message, handle, bio, domain, id…)
-// can't inject ANSI/OSC escapes to spoof output — e.g. cursor-up + repaint to overwrite a
-// "✗ MISMATCH" verdict with "✓ VERIFIED", rewrite the window title, or hijack the terminal.
-// Display-only: NEVER apply to bytes that get hashed/verified (it would change the hash).
-const CTRL = new RegExp("[\\u0000-\\u001f\\u007f-\\u009f]", "g");
+// Strip dangerous characters from UNTRUSTED strings before printing them to a TTY, so a
+// hostile server/chain field (title, body, message, ERROR string, txid/id, handle, bio,
+// domain…) can't (a) inject ANSI/OSC escapes to spoof output — cursor-up + repaint to
+// overwrite a "✗ MISMATCH" with "✓ VERIFIED", rewrite the window title, OSC-8 link spoof,
+// OSC-52 clipboard write — or (b) use Unicode bidi-overrides / zero-width chars to spoof
+// a displayed address/name/amount (CLI-9). Display-only: NEVER apply to bytes that get
+// hashed/verified (it would change the hash).
+//   • C0/C1 control + DEL (incl. ESC 0x1b — the ANSI/OSC lead-in)
+//   • bidi controls: LRM/RLM U+200E/F, ALM U+061C, LRE..RLO U+202A-E, LRI..PDI U+2066-9
+//   • zero-width / joiners / BOM: ZWSP/ZWNJ/ZWJ U+200B-D, WJ U+2060, BOM U+FEFF
+const CTRL = new RegExp("[\\u0000-\\u001f\\u007f-\\u009f\\u061c\\u200b-\\u200f\\u2060\\u2066-\\u2069\\u202a-\\u202e\\ufeff]", "g");
 export function san(s) { return String(s ?? "").replace(CTRL, ""); }
 export function ok(s) { return c.green("✓ ") + s; }
 export function warn(s) { return c.gray("⚠ ") + s; }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inversealtruism/cairn-cli",
-  "version": "0.3.2",
+  "version": "0.3.6",
   "description": "CLI for Compute Substrate / Cairn — browse the board/wall/network, and send CSD, propose, attest, and place stones non-custodially by driving your own installed `csd` wallet (cairn never holds your key; works node-less via the Cairn proxy).",
   "type": "module",
   "bin": {
@@ -25,7 +25,7 @@
     "clean": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
     "build": "npm run clean && tsc",
     "dev": "tsx src/cli.ts",
-    "test": "npm run build && node test/security.mjs && node test/e2e.mjs",
+    "test": "npm run build && node test/security.mjs && node test/cairnx.mjs && node test/e2e.mjs",
     "prepare": "npm run clean && tsc",
     "prepublishOnly": "npm run clean && tsc"
   },
@@ -41,7 +41,7 @@
     "typescript": "^5.7.2"
   },
   "dependencies": {
-    "@inversealtruism/csd-codec": "0.1.3",
-    "@inversealtruism/csd-registry": "0.1.3"
+    "@inversealtruism/csd-codec": "0.1.14",
+    "@inversealtruism/csd-registry": "0.1.14"
   }
 }