@abraca/cli 1.5.0

package/dist/abracadabra-cli.cjs

@@ -0,0 +1,3301 @@
+#!/usr/bin/env node
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let yjs = require("yjs");
+yjs = __toESM(yjs);
+let _abraca_dabra = require("@abraca/dabra");
+let _noble_ed25519 = require("@noble/ed25519");
+_noble_ed25519 = __toESM(_noble_ed25519);
+let node_fs_promises = require("node:fs/promises");
+let node_fs = require("node:fs");
+node_fs = __toESM(node_fs);
+let node_os = require("node:os");
+let node_path = require("node:path");
+node_path = __toESM(node_path);
+
+//#region packages/cli/src/parser.ts
+/**
+* Parse CLI arguments into a structured object.
+* @param argv Raw process.argv (includes node path and script path)
+*/
+function parseArgs(argv) {
+	const args = argv.slice(2);
+	const result = {
+		command: "help",
+		params: {},
+		flags: /* @__PURE__ */ new Set(),
+		positional: []
+	};
+	let commandFound = false;
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg.startsWith("--")) {
+			const stripped = arg.slice(2);
+			const eqIdx = stripped.indexOf("=");
+			if (eqIdx !== -1) {
+				const key = stripped.slice(0, eqIdx);
+				const value = stripped.slice(eqIdx + 1);
+				result.params[key] = value;
+			} else result.flags.add(stripped);
+			continue;
+		}
+		const eqIdx = arg.indexOf("=");
+		if (eqIdx !== -1 && eqIdx > 0) {
+			const key = arg.slice(0, eqIdx);
+			let value = arg.slice(eqIdx + 1);
+			if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1);
+			result.params[key] = value;
+			continue;
+		}
+		if (!commandFound) {
+			result.command = arg;
+			commandFound = true;
+			continue;
+		}
+		result.positional.push(arg);
+	}
+	return result;
+}
+
+//#endregion
+//#region packages/cli/node_modules/@noble/hashes/esm/utils.js
+/** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */
+function isBytes(a) {
+	return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+/** Asserts something is Uint8Array. */
+function abytes(b, ...lengths) {
+	if (!isBytes(b)) throw new Error("Uint8Array expected");
+	if (lengths.length > 0 && !lengths.includes(b.length)) throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
+}
+/** Asserts a hash instance has not been destroyed / finished */
+function aexists(instance, checkFinished = true) {
+	if (instance.destroyed) throw new Error("Hash instance has been destroyed");
+	if (checkFinished && instance.finished) throw new Error("Hash#digest() has already been called");
+}
+/** Asserts output is properly-sized byte array */
+function aoutput(out, instance) {
+	abytes(out);
+	const min = instance.outputLen;
+	if (out.length < min) throw new Error("digestInto() expects output buffer of length at least " + min);
+}
+/** Zeroize a byte array. Warning: JS provides no guarantees. */
+function clean(...arrays) {
+	for (let i = 0; i < arrays.length; i++) arrays[i].fill(0);
+}
+/** Create DataView of an array for easy byte-level manipulation. */
+function createView(arr) {
+	return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+/** Is current platform little-endian? Most are. Big-Endian platform: IBM */
+const isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
+const hasHexBuiltin = typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function";
+/**
+* Converts string to bytes using UTF8 encoding.
+* @example utf8ToBytes('abc') // Uint8Array.from([97, 98, 99])
+*/
+function utf8ToBytes(str) {
+	if (typeof str !== "string") throw new Error("string expected");
+	return new Uint8Array(new TextEncoder().encode(str));
+}
+/**
+* Normalizes (non-hex) string or Uint8Array to Uint8Array.
+* Warning: when Uint8Array is passed, it would NOT get copied.
+* Keep in mind for future mutable operations.
+*/
+function toBytes(data) {
+	if (typeof data === "string") data = utf8ToBytes(data);
+	abytes(data);
+	return data;
+}
+/** For runtime check if class implements interface */
+var Hash = class {};
+/** Wraps hash function, creating an interface on top of it */
+function createHasher(hashCons) {
+	const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+	const tmp = hashCons();
+	hashC.outputLen = tmp.outputLen;
+	hashC.blockLen = tmp.blockLen;
+	hashC.create = () => hashCons();
+	return hashC;
+}
+
+//#endregion
+//#region packages/cli/node_modules/@noble/hashes/esm/_md.js
+/**
+* Internal Merkle-Damgard hash utils.
+* @module
+*/
+/** Polyfill for Safari 14. https://caniuse.com/mdn-javascript_builtins_dataview_setbiguint64 */
+function setBigUint64(view, byteOffset, value, isLE) {
+	if (typeof view.setBigUint64 === "function") return view.setBigUint64(byteOffset, value, isLE);
+	const _32n = BigInt(32);
+	const _u32_max = BigInt(4294967295);
+	const wh = Number(value >> _32n & _u32_max);
+	const wl = Number(value & _u32_max);
+	const h = isLE ? 4 : 0;
+	const l = isLE ? 0 : 4;
+	view.setUint32(byteOffset + h, wh, isLE);
+	view.setUint32(byteOffset + l, wl, isLE);
+}
+/**
+* Merkle-Damgard hash construction base class.
+* Could be used to create MD5, RIPEMD, SHA1, SHA2.
+*/
+var HashMD = class extends Hash {
+	constructor(blockLen, outputLen, padOffset, isLE) {
+		super();
+		this.finished = false;
+		this.length = 0;
+		this.pos = 0;
+		this.destroyed = false;
+		this.blockLen = blockLen;
+		this.outputLen = outputLen;
+		this.padOffset = padOffset;
+		this.isLE = isLE;
+		this.buffer = new Uint8Array(blockLen);
+		this.view = createView(this.buffer);
+	}
+	update(data) {
+		aexists(this);
+		data = toBytes(data);
+		abytes(data);
+		const { view, buffer, blockLen } = this;
+		const len = data.length;
+		for (let pos = 0; pos < len;) {
+			const take = Math.min(blockLen - this.pos, len - pos);
+			if (take === blockLen) {
+				const dataView = createView(data);
+				for (; blockLen <= len - pos; pos += blockLen) this.process(dataView, pos);
+				continue;
+			}
+			buffer.set(data.subarray(pos, pos + take), this.pos);
+			this.pos += take;
+			pos += take;
+			if (this.pos === blockLen) {
+				this.process(view, 0);
+				this.pos = 0;
+			}
+		}
+		this.length += data.length;
+		this.roundClean();
+		return this;
+	}
+	digestInto(out) {
+		aexists(this);
+		aoutput(out, this);
+		this.finished = true;
+		const { buffer, view, blockLen, isLE } = this;
+		let { pos } = this;
+		buffer[pos++] = 128;
+		clean(this.buffer.subarray(pos));
+		if (this.padOffset > blockLen - pos) {
+			this.process(view, 0);
+			pos = 0;
+		}
+		for (let i = pos; i < blockLen; i++) buffer[i] = 0;
+		setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);
+		this.process(view, 0);
+		const oview = createView(out);
+		const len = this.outputLen;
+		if (len % 4) throw new Error("_sha2: outputLen should be aligned to 32bit");
+		const outLen = len / 4;
+		const state = this.get();
+		if (outLen > state.length) throw new Error("_sha2: outputLen bigger than state");
+		for (let i = 0; i < outLen; i++) oview.setUint32(4 * i, state[i], isLE);
+	}
+	digest() {
+		const { buffer, outputLen } = this;
+		this.digestInto(buffer);
+		const res = buffer.slice(0, outputLen);
+		this.destroy();
+		return res;
+	}
+	_cloneInto(to) {
+		to || (to = new this.constructor());
+		to.set(...this.get());
+		const { blockLen, buffer, length, finished, destroyed, pos } = this;
+		to.destroyed = destroyed;
+		to.finished = finished;
+		to.length = length;
+		to.pos = pos;
+		if (length % blockLen) to.buffer.set(buffer);
+		return to;
+	}
+	clone() {
+		return this._cloneInto();
+	}
+};
+/** Initial SHA512 state. Bits 0..64 of frac part of sqrt of primes 2..19 */
+const SHA512_IV = /* @__PURE__ */ Uint32Array.from([
+	1779033703,
+	4089235720,
+	3144134277,
+	2227873595,
+	1013904242,
+	4271175723,
+	2773480762,
+	1595750129,
+	1359893119,
+	2917565137,
+	2600822924,
+	725511199,
+	528734635,
+	4215389547,
+	1541459225,
+	327033209
+]);
+
+//#endregion
+//#region packages/cli/node_modules/@noble/hashes/esm/_u64.js
+/**
+* Internal helpers for u64. BigUint64Array is too slow as per 2025, so we implement it using Uint32Array.
+* @todo re-check https://issues.chromium.org/issues/42212588
+* @module
+*/
+const U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+const _32n = /* @__PURE__ */ BigInt(32);
+function fromBig(n, le = false) {
+	if (le) return {
+		h: Number(n & U32_MASK64),
+		l: Number(n >> _32n & U32_MASK64)
+	};
+	return {
+		h: Number(n >> _32n & U32_MASK64) | 0,
+		l: Number(n & U32_MASK64) | 0
+	};
+}
+function split(lst, le = false) {
+	const len = lst.length;
+	let Ah = new Uint32Array(len);
+	let Al = new Uint32Array(len);
+	for (let i = 0; i < len; i++) {
+		const { h, l } = fromBig(lst[i], le);
+		[Ah[i], Al[i]] = [h, l];
+	}
+	return [Ah, Al];
+}
+const shrSH = (h, _l, s) => h >>> s;
+const shrSL = (h, l, s) => h << 32 - s | l >>> s;
+const rotrSH = (h, l, s) => h >>> s | l << 32 - s;
+const rotrSL = (h, l, s) => h << 32 - s | l >>> s;
+const rotrBH = (h, l, s) => h << 64 - s | l >>> s - 32;
+const rotrBL = (h, l, s) => h >>> s - 32 | l << 64 - s;
+function add(Ah, Al, Bh, Bl) {
+	const l = (Al >>> 0) + (Bl >>> 0);
+	return {
+		h: Ah + Bh + (l / 2 ** 32 | 0) | 0,
+		l: l | 0
+	};
+}
+const add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
+const add3H = (low, Ah, Bh, Ch) => Ah + Bh + Ch + (low / 2 ** 32 | 0) | 0;
+const add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
+const add4H = (low, Ah, Bh, Ch, Dh) => Ah + Bh + Ch + Dh + (low / 2 ** 32 | 0) | 0;
+const add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
+const add5H = (low, Ah, Bh, Ch, Dh, Eh) => Ah + Bh + Ch + Dh + Eh + (low / 2 ** 32 | 0) | 0;
+
+//#endregion
+//#region packages/cli/node_modules/@noble/hashes/esm/sha2.js
+/**
+* SHA2 hash function. A.k.a. sha256, sha384, sha512, sha512_224, sha512_256.
+* SHA256 is the fastest hash implementable in JS, even faster than Blake3.
+* Check out [RFC 4634](https://datatracker.ietf.org/doc/html/rfc4634) and
+* [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).
+* @module
+*/
+const K512 = split([
+	"0x428a2f98d728ae22",
+	"0x7137449123ef65cd",
+	"0xb5c0fbcfec4d3b2f",
+	"0xe9b5dba58189dbbc",
+	"0x3956c25bf348b538",
+	"0x59f111f1b605d019",
+	"0x923f82a4af194f9b",
+	"0xab1c5ed5da6d8118",
+	"0xd807aa98a3030242",
+	"0x12835b0145706fbe",
+	"0x243185be4ee4b28c",
+	"0x550c7dc3d5ffb4e2",
+	"0x72be5d74f27b896f",
+	"0x80deb1fe3b1696b1",
+	"0x9bdc06a725c71235",
+	"0xc19bf174cf692694",
+	"0xe49b69c19ef14ad2",
+	"0xefbe4786384f25e3",
+	"0x0fc19dc68b8cd5b5",
+	"0x240ca1cc77ac9c65",
+	"0x2de92c6f592b0275",
+	"0x4a7484aa6ea6e483",
+	"0x5cb0a9dcbd41fbd4",
+	"0x76f988da831153b5",
+	"0x983e5152ee66dfab",
+	"0xa831c66d2db43210",
+	"0xb00327c898fb213f",
+	"0xbf597fc7beef0ee4",
+	"0xc6e00bf33da88fc2",
+	"0xd5a79147930aa725",
+	"0x06ca6351e003826f",
+	"0x142929670a0e6e70",
+	"0x27b70a8546d22ffc",
+	"0x2e1b21385c26c926",
+	"0x4d2c6dfc5ac42aed",
+	"0x53380d139d95b3df",
+	"0x650a73548baf63de",
+	"0x766a0abb3c77b2a8",
+	"0x81c2c92e47edaee6",
+	"0x92722c851482353b",
+	"0xa2bfe8a14cf10364",
+	"0xa81a664bbc423001",
+	"0xc24b8b70d0f89791",
+	"0xc76c51a30654be30",
+	"0xd192e819d6ef5218",
+	"0xd69906245565a910",
+	"0xf40e35855771202a",
+	"0x106aa07032bbd1b8",
+	"0x19a4c116b8d2d0c8",
+	"0x1e376c085141ab53",
+	"0x2748774cdf8eeb99",
+	"0x34b0bcb5e19b48a8",
+	"0x391c0cb3c5c95a63",
+	"0x4ed8aa4ae3418acb",
+	"0x5b9cca4f7763e373",
+	"0x682e6ff3d6b2b8a3",
+	"0x748f82ee5defb2fc",
+	"0x78a5636f43172f60",
+	"0x84c87814a1f0ab72",
+	"0x8cc702081a6439ec",
+	"0x90befffa23631e28",
+	"0xa4506cebde82bde9",
+	"0xbef9a3f7b2c67915",
+	"0xc67178f2e372532b",
+	"0xca273eceea26619c",
+	"0xd186b8c721c0c207",
+	"0xeada7dd6cde0eb1e",
+	"0xf57d4f7fee6ed178",
+	"0x06f067aa72176fba",
+	"0x0a637dc5a2c898a6",
+	"0x113f9804bef90dae",
+	"0x1b710b35131c471b",
+	"0x28db77f523047d84",
+	"0x32caab7b40c72493",
+	"0x3c9ebe0a15c9bebc",
+	"0x431d67c49c100d4c",
+	"0x4cc5d4becb3e42b6",
+	"0x597f299cfc657e2a",
+	"0x5fcb6fab3ad6faec",
+	"0x6c44198c4a475817"
+].map((n) => BigInt(n)));
+const SHA512_Kh = K512[0];
+const SHA512_Kl = K512[1];
+const SHA512_W_H = /* @__PURE__ */ new Uint32Array(80);
+const SHA512_W_L = /* @__PURE__ */ new Uint32Array(80);
+var SHA512 = class extends HashMD {
+	constructor(outputLen = 64) {
+		super(128, outputLen, 16, false);
+		this.Ah = SHA512_IV[0] | 0;
+		this.Al = SHA512_IV[1] | 0;
+		this.Bh = SHA512_IV[2] | 0;
+		this.Bl = SHA512_IV[3] | 0;
+		this.Ch = SHA512_IV[4] | 0;
+		this.Cl = SHA512_IV[5] | 0;
+		this.Dh = SHA512_IV[6] | 0;
+		this.Dl = SHA512_IV[7] | 0;
+		this.Eh = SHA512_IV[8] | 0;
+		this.El = SHA512_IV[9] | 0;
+		this.Fh = SHA512_IV[10] | 0;
+		this.Fl = SHA512_IV[11] | 0;
+		this.Gh = SHA512_IV[12] | 0;
+		this.Gl = SHA512_IV[13] | 0;
+		this.Hh = SHA512_IV[14] | 0;
+		this.Hl = SHA512_IV[15] | 0;
+	}
+	get() {
+		const { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
+		return [
+			Ah,
+			Al,
+			Bh,
+			Bl,
+			Ch,
+			Cl,
+			Dh,
+			Dl,
+			Eh,
+			El,
+			Fh,
+			Fl,
+			Gh,
+			Gl,
+			Hh,
+			Hl
+		];
+	}
+	set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl) {
+		this.Ah = Ah | 0;
+		this.Al = Al | 0;
+		this.Bh = Bh | 0;
+		this.Bl = Bl | 0;
+		this.Ch = Ch | 0;
+		this.Cl = Cl | 0;
+		this.Dh = Dh | 0;
+		this.Dl = Dl | 0;
+		this.Eh = Eh | 0;
+		this.El = El | 0;
+		this.Fh = Fh | 0;
+		this.Fl = Fl | 0;
+		this.Gh = Gh | 0;
+		this.Gl = Gl | 0;
+		this.Hh = Hh | 0;
+		this.Hl = Hl | 0;
+	}
+	process(view, offset) {
+		for (let i = 0; i < 16; i++, offset += 4) {
+			SHA512_W_H[i] = view.getUint32(offset);
+			SHA512_W_L[i] = view.getUint32(offset += 4);
+		}
+		for (let i = 16; i < 80; i++) {
+			const W15h = SHA512_W_H[i - 15] | 0;
+			const W15l = SHA512_W_L[i - 15] | 0;
+			const s0h = rotrSH(W15h, W15l, 1) ^ rotrSH(W15h, W15l, 8) ^ shrSH(W15h, W15l, 7);
+			const s0l = rotrSL(W15h, W15l, 1) ^ rotrSL(W15h, W15l, 8) ^ shrSL(W15h, W15l, 7);
+			const W2h = SHA512_W_H[i - 2] | 0;
+			const W2l = SHA512_W_L[i - 2] | 0;
+			const s1h = rotrSH(W2h, W2l, 19) ^ rotrBH(W2h, W2l, 61) ^ shrSH(W2h, W2l, 6);
+			const s1l = rotrSL(W2h, W2l, 19) ^ rotrBL(W2h, W2l, 61) ^ shrSL(W2h, W2l, 6);
+			const SUMl = add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);
+			SHA512_W_H[i] = add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]) | 0;
+			SHA512_W_L[i] = SUMl | 0;
+		}
+		let { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
+		for (let i = 0; i < 80; i++) {
+			const sigma1h = rotrSH(Eh, El, 14) ^ rotrSH(Eh, El, 18) ^ rotrBH(Eh, El, 41);
+			const sigma1l = rotrSL(Eh, El, 14) ^ rotrSL(Eh, El, 18) ^ rotrBL(Eh, El, 41);
+			const CHIh = Eh & Fh ^ ~Eh & Gh;
+			const CHIl = El & Fl ^ ~El & Gl;
+			const T1ll = add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);
+			const T1h = add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);
+			const T1l = T1ll | 0;
+			const sigma0h = rotrSH(Ah, Al, 28) ^ rotrBH(Ah, Al, 34) ^ rotrBH(Ah, Al, 39);
+			const sigma0l = rotrSL(Ah, Al, 28) ^ rotrBL(Ah, Al, 34) ^ rotrBL(Ah, Al, 39);
+			const MAJh = Ah & Bh ^ Ah & Ch ^ Bh & Ch;
+			const MAJl = Al & Bl ^ Al & Cl ^ Bl & Cl;
+			Hh = Gh | 0;
+			Hl = Gl | 0;
+			Gh = Fh | 0;
+			Gl = Fl | 0;
+			Fh = Eh | 0;
+			Fl = El | 0;
+			({h: Eh, l: El} = add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));
+			Dh = Ch | 0;
+			Dl = Cl | 0;
+			Ch = Bh | 0;
+			Cl = Bl | 0;
+			Bh = Ah | 0;
+			Bl = Al | 0;
+			const All = add3L(T1l, sigma0l, MAJl);
+			Ah = add3H(All, T1h, sigma0h, MAJh);
+			Al = All | 0;
+		}
+		({h: Ah, l: Al} = add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));
+		({h: Bh, l: Bl} = add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));
+		({h: Ch, l: Cl} = add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));
+		({h: Dh, l: Dl} = add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));
+		({h: Eh, l: El} = add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));
+		({h: Fh, l: Fl} = add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));
+		({h: Gh, l: Gl} = add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));
+		({h: Hh, l: Hl} = add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));
+		this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);
+	}
+	roundClean() {
+		clean(SHA512_W_H, SHA512_W_L);
+	}
+	destroy() {
+		clean(this.buffer);
+		this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+	}
+};
+/** SHA2-512 hash function from RFC 4634. */
+const sha512 = /* @__PURE__ */ createHasher(() => new SHA512());
+
+//#endregion
+//#region packages/cli/src/crypto.ts
+/**
+* Ed25519 key generation, persistence, and challenge signing for CLI auth.
+* Mirrors @abraca/mcp/src/crypto.ts — standalone to avoid MCP SDK dependency.
+*/
+_noble_ed25519.etc.sha512Sync = (...msgs) => sha512(_noble_ed25519.etc.concatBytes(...msgs));
+const DEFAULT_KEY_PATH = (0, node_path.join)((0, node_os.homedir)(), ".abracadabra", "cli.key");
+function toBase64url(bytes) {
+	return Buffer.from(bytes).toString("base64url");
+}
+function fromBase64url(b64) {
+	return new Uint8Array(Buffer.from(b64, "base64url"));
+}
+/**
+* Load an existing Ed25519 keypair from disk, or generate and persist a new one.
+* The file stores the raw 32-byte private key seed.
+*/
+async function loadOrCreateKeypair(keyPath) {
+	const path = keyPath || DEFAULT_KEY_PATH;
+	if ((0, node_fs.existsSync)(path)) {
+		const seed = await (0, node_fs_promises.readFile)(path);
+		if (seed.length !== 32) throw new Error(`Invalid key file at ${path}: expected 32 bytes, got ${seed.length}`);
+		const privateKey = new Uint8Array(seed);
+		return {
+			privateKey,
+			publicKeyB64: toBase64url(_noble_ed25519.getPublicKey(privateKey))
+		};
+	}
+	const privateKey = _noble_ed25519.utils.randomPrivateKey();
+	const publicKey = _noble_ed25519.getPublicKey(privateKey);
+	const dir = (0, node_path.dirname)(path);
+	if (!(0, node_fs.existsSync)(dir)) await (0, node_fs_promises.mkdir)(dir, {
+		recursive: true,
+		mode: 448
+	});
+	await (0, node_fs_promises.writeFile)(path, Buffer.from(privateKey), { mode: 384 });
+	console.error(`[abracadabra] Generated new keypair at ${path}`);
+	console.error(`[abracadabra] Public key: ${toBase64url(publicKey)}`);
+	return {
+		privateKey,
+		publicKeyB64: toBase64url(publicKey)
+	};
+}
+/** Sign a base64url challenge with the private key; returns base64url signature. */
+function signChallenge(challengeB64, privateKey) {
+	const challenge = fromBase64url(challengeB64);
+	return toBase64url(_noble_ed25519.sign(challenge, privateKey));
+}
+
+//#endregion
+//#region packages/cli/src/connection.ts
+/**
+* CLIConnection — manages the CRDT connection lifecycle for the CLI.
+*
+* Handles: Ed25519 auth → space discovery → Y.Doc sync → awareness.
+* Reuses the same patterns as AbracadabraMCPServer but without MCP SDK dependency.
+*/
+function waitForSync(provider, timeoutMs = 15e3) {
+	return new Promise((resolve, reject) => {
+		const timer = setTimeout(() => {
+			provider.off("synced", handler);
+			reject(/* @__PURE__ */ new Error(`Sync timed out after ${timeoutMs}ms`));
+		}, timeoutMs);
+		function handler() {
+			clearTimeout(timer);
+			resolve();
+		}
+		provider.on("synced", handler);
+	});
+}
+/** Map a DocumentMeta to SpaceMeta shape for display compatibility. */
+function docToSpaceMeta(doc) {
+	const publicAccess = doc.public_access;
+	let visibility = "private";
+	if (publicAccess && publicAccess !== "none") visibility = "public";
+	return {
+		id: doc.id,
+		doc_id: doc.id,
+		name: doc.label ?? doc.id,
+		description: doc.description ?? null,
+		visibility,
+		is_hub: doc.is_hub ?? false,
+		owner_id: doc.owner_id ?? null,
+		created_at: 0,
+		updated_at: doc.updated_at ?? 0,
+		public_access: publicAccess ?? null
+	};
+}
+var CLIConnection = class {
+	config;
+	client;
+	_serverInfo = null;
+	_rootDocId = null;
+	_spaces = [];
+	_rootDoc = null;
+	_rootProvider = null;
+	_userId = null;
+	_signFn = null;
+	childCache = /* @__PURE__ */ new Map();
+	constructor(config) {
+		this.config = config;
+		this.client = new _abraca_dabra.AbracadabraClient({
+			url: config.url,
+			persistAuth: false
+		});
+	}
+	get displayName() {
+		return this.config.name || "CLI User";
+	}
+	get displayColor() {
+		return this.config.color || "hsl(45, 90%, 55%)";
+	}
+	get serverInfo() {
+		return this._serverInfo;
+	}
+	get rootDocId() {
+		return this._rootDocId;
+	}
+	get spaces() {
+		return this._spaces;
+	}
+	get rootDoc() {
+		return this._rootDoc;
+	}
+	get rootProvider() {
+		return this._rootProvider;
+	}
+	get userId() {
+		return this._userId;
+	}
+	log(msg) {
+		if (!this.config.quiet) console.error(`[abracadabra] ${msg}`);
+	}
+	/** Connect to the server: authenticate, discover spaces, sync root doc. */
+	async connect() {
+		const keypair = await loadOrCreateKeypair(this.config.keyFile);
+		this._userId = keypair.publicKeyB64;
+		const signFn = (challenge) => Promise.resolve(signChallenge(challenge, keypair.privateKey));
+		this._signFn = signFn;
+		try {
+			await this.client.loginWithKey(keypair.publicKeyB64, signFn);
+		} catch (err) {
+			const status = err?.status ?? err?.response?.status;
+			if (status === 404 || status === 422) {
+				this.log("Key not registered, creating new account...");
+				await this.client.registerWithKey({
+					publicKey: keypair.publicKeyB64,
+					username: this.displayName.replace(/\s+/g, "-").toLowerCase(),
+					displayName: this.displayName,
+					deviceName: "CLI",
+					inviteCode: this.config.inviteCode
+				});
+				await this.client.loginWithKey(keypair.publicKeyB64, signFn);
+			} else throw err;
+		}
+		this.log(`Authenticated as ${this.displayName} (${keypair.publicKeyB64.slice(0, 12)}...)`);
+		this._serverInfo = await this.client.serverInfo();
+		let initialDocId = this._serverInfo.index_doc_id ?? null;
+		try {
+			const roots = await this.client.listRootDocuments();
+			this._spaces = roots.map(docToSpaceMeta);
+			const hub = roots.find((d) => d.is_hub);
+			if (hub) {
+				initialDocId = hub.id;
+				this.log(`Hub document: ${hub.label ?? hub.id} (${hub.id})`);
+			} else if (roots.length > 0) {
+				initialDocId = roots[0].id;
+				this.log(`No hub, using first root doc: ${roots[0].label ?? roots[0].id}`);
+			}
+		} catch {
+			try {
+				this._spaces = await this.client.listSpaces();
+				const hub = this._spaces.find((s) => s.is_hub);
+				if (hub) initialDocId = hub.doc_id;
+				else if (this._spaces.length > 0) initialDocId = this._spaces[0].doc_id;
+			} catch {
+				this.log("Neither /docs?root=true nor /spaces available, using index_doc_id");
+			}
+		}
+		if (!initialDocId) throw new Error("No entry point found: server has neither spaces nor index_doc_id configured.");
+		this._rootDocId = initialDocId;
+		const doc = new yjs.Doc({ guid: initialDocId });
+		const provider = new _abraca_dabra.AbracadabraProvider({
+			name: initialDocId,
+			document: doc,
+			client: this.client,
+			disableOfflineStore: true,
+			subdocLoading: "lazy"
+		});
+		await waitForSync(provider);
+		provider.awareness.setLocalStateField("user", {
+			name: this.displayName,
+			color: this.displayColor,
+			publicKey: this._userId,
+			isAgent: false
+		});
+		provider.awareness.setLocalStateField("status", null);
+		this._rootDoc = doc;
+		this._rootProvider = provider;
+		this.log("Connected and synced");
+	}
+	/** Switch active space to a different root document. */
+	async switchSpace(docId) {
+		for (const [, cached] of this.childCache) cached.provider.destroy();
+		this.childCache.clear();
+		if (this._rootProvider) {
+			this._rootProvider.destroy();
+			this._rootProvider = null;
+		}
+		this._rootDoc = null;
+		if (!this.client.isTokenValid() && this._signFn && this._userId) await this.client.loginWithKey(this._userId, this._signFn);
+		const doc = new yjs.Doc({ guid: docId });
+		const provider = new _abraca_dabra.AbracadabraProvider({
+			name: docId,
+			document: doc,
+			client: this.client,
+			disableOfflineStore: true,
+			subdocLoading: "lazy"
+		});
+		await waitForSync(provider);
+		provider.awareness.setLocalStateField("user", {
+			name: this.displayName,
+			color: this.displayColor,
+			publicKey: this._userId,
+			isAgent: false
+		});
+		this._rootDoc = doc;
+		this._rootProvider = provider;
+		this._rootDocId = docId;
+		this.log(`Switched to space ${docId}`);
+	}
+	/** Get the root doc-tree Y.Map. */
+	getTreeMap() {
+		return this._rootDoc?.getMap("doc-tree") ?? null;
+	}
+	/** Get the root doc-trash Y.Map. */
+	getTrashMap() {
+		return this._rootDoc?.getMap("doc-trash") ?? null;
+	}
+	/** Get or create a child provider for a document. */
+	async getChildProvider(docId) {
+		const cached = this.childCache.get(docId);
+		if (cached) {
+			cached.lastAccessed = Date.now();
+			return cached.provider;
+		}
+		if (!this._rootProvider) throw new Error("Not connected. Call connect() first.");
+		if (!this.client.isTokenValid() && this._signFn && this._userId) await this.client.loginWithKey(this._userId, this._signFn);
+		const childProvider = await this._rootProvider.loadChild(docId);
+		await waitForSync(childProvider);
+		childProvider.awareness.setLocalStateField("user", {
+			name: this.displayName,
+			color: this.displayColor,
+			publicKey: this._userId,
+			isAgent: false
+		});
+		this.childCache.set(docId, {
+			provider: childProvider,
+			lastAccessed: Date.now()
+		});
+		return childProvider;
+	}
+	/** Graceful shutdown. */
+	async destroy() {
+		for (const [, cached] of this.childCache) cached.provider.destroy();
+		this.childCache.clear();
+		if (this._rootProvider) {
+			this._rootProvider.awareness.setLocalStateField("status", null);
+			this._rootProvider.destroy();
+			this._rootProvider = null;
+		}
+		this._rootDoc = null;
+		this.log("Disconnected");
+	}
+};
+
+//#endregion
+//#region packages/cli/src/command.ts
+const commands = [];
+function registerCommand(cmd) {
+	commands.push(cmd);
+}
+function getCommand(name) {
+	return commands.find((c) => c.name === name || c.aliases?.includes(name)) ?? null;
+}
+function getAllCommands() {
+	return [...commands];
+}
+
+//#endregion
+//#region packages/cli/src/output.ts
+function getFormat(args, defaultFormat = "text") {
+	const f = args.params["format"];
+	if (f && [
+		"json",
+		"tsv",
+		"tree",
+		"text",
+		"md"
+	].includes(f)) return f;
+	return defaultFormat;
+}
+/** Print a JSON-serializable value. */
+function printJson(data) {
+	return JSON.stringify(data, null, 2);
+}
+/** Format a tree of nested items with box-drawing characters. */
+function printTree(items, opts = {}) {
+	const lines = [];
+	for (let i = 0; i < items.length; i++) {
+		const item = items[i];
+		const isLast = i === items.length - 1;
+		const prefix = (opts.isLast ?? []).map((last) => last ? "    " : "│   ").join("");
+		const connector = isLast ? "└── " : "├── ";
+		const typeSuffix = item.type ? ` (${item.type})` : "";
+		lines.push(`${prefix}${connector}${item.label}${typeSuffix}`);
+		if (item.children && item.children.length > 0) lines.push(printTree(item.children, { isLast: [...opts.isLast ?? [], isLast] }));
+	}
+	return lines.join("\n");
+}
+/** Format relative time (e.g. "2m ago", "1h ago"). */
+function relativeTime(timestamp) {
+	if (!timestamp) return "—";
+	const diff = Date.now() - timestamp;
+	if (diff < 0) return "just now";
+	if (diff < 6e4) return `${Math.floor(diff / 1e3)}s ago`;
+	if (diff < 36e5) return `${Math.floor(diff / 6e4)}m ago`;
+	if (diff < 864e5) return `${Math.floor(diff / 36e5)}h ago`;
+	return `${Math.floor(diff / 864e5)}d ago`;
+}
+/** Pad a string to a fixed width. */
+function pad(str, width) {
+	if (str.length >= width) return str.slice(0, width);
+	return str + " ".repeat(width - str.length);
+}
+/** Format a table with auto-column widths. */
+function printTable(rows, headers) {
+	const allRows = headers ? [headers, ...rows] : rows;
+	if (allRows.length === 0) return "";
+	const colCount = Math.max(...allRows.map((r) => r.length));
+	const widths = [];
+	for (let c = 0; c < colCount; c++) widths[c] = Math.max(...allRows.map((r) => (r[c] ?? "").length));
+	return allRows.map((row) => row.map((cell, i) => pad(cell, widths[i])).join("  ")).join("\n");
+}
+
+//#endregion
+//#region packages/cli/src/commands/help.ts
+/**
+* help + version commands.
+*/
+registerCommand({
+	name: "help",
+	aliases: ["h", "?"],
+	description: "Show list of all available commands.",
+	usage: "help [<command>]",
+	async run(_conn, args) {
+		const target = args.positional[0];
+		if (target) {
+			const cmd = getAllCommands().find((c) => c.name === target || c.aliases?.includes(target));
+			if (!cmd) return `Unknown command: ${target}\n\nRun 'abracadabra help' to see all commands.`;
+			const aliasStr = cmd.aliases?.length ? ` (aliases: ${cmd.aliases.join(", ")})` : "";
+			let text = `${cmd.name}${aliasStr}\n  ${cmd.description}`;
+			if (cmd.usage) text += `\n\n  Usage: abracadabra ${cmd.usage}`;
+			return text;
+		}
+		const cmds = getAllCommands();
+		const maxLen = Math.max(...cmds.map((c) => c.name.length));
+		return [
+			"Abracadabra CLI — interact with CRDT document workspaces from the terminal.",
+			"",
+			"Usage: abracadabra <command> [key=value ...] [--flags]",
+			"",
+			"Commands:",
+			...cmds.map((c) => {
+				const aliasStr = c.aliases?.length ? ` (${c.aliases.join(", ")})` : "";
+				return `  ${pad(c.name, maxLen + 2)}${c.description}${aliasStr}`;
+			}),
+			"",
+			"Environment:",
+			"  ABRA_URL          Server URL (required)",
+			"  ABRA_KEY_FILE     Path to Ed25519 key file",
+			"  ABRA_INVITE_CODE  Invite code for first-run registration",
+			"  ABRA_NAME         Display name",
+			"  ABRA_COLOR        Presence color",
+			"",
+			"Run \"abracadabra help <command>\" for command-specific help."
+		].join("\n");
+	}
+});
+registerCommand({
+	name: "version",
+	aliases: ["v"],
+	description: "Show CLI and server version.",
+	async run(conn) {
+		const lines = [`Abracadabra CLI  v1.0.0`];
+		if (conn?.serverInfo) {
+			const si = conn.serverInfo;
+			if (si.version) lines.push(`Server           v${si.version}`);
+			if (si.name) lines.push(`Server name      ${si.name}`);
+			if (si.protocol_version) lines.push(`Protocol         ${si.protocol_version}`);
+		}
+		return lines.join("\n");
+	}
+});
+
+//#endregion
+//#region packages/cli/src/resolve.ts
+/**
+* Document resolution utilities for the CLI.
+*
+* Resolves documents by id, name (label), or path (label chain from root).
+* Similar to Obsidian's file= / path= resolution.
+*/
+/** Safely read a tree map value, converting Y.Map to plain object if needed. */
+function toPlain$2(val) {
+	return val instanceof yjs.Map ? val.toJSON() : val;
+}
+/** Read all tree entries from the Y.Map. */
+function readEntries(treeMap) {
+	const entries = [];
+	treeMap.forEach((raw, id) => {
+		const value = toPlain$2(raw);
+		if (typeof value !== "object" || value === null) return;
+		entries.push({
+			id,
+			label: value.label || "Untitled",
+			parentId: value.parentId ?? null,
+			order: value.order ?? 0,
+			type: value.type,
+			meta: value.meta,
+			createdAt: value.createdAt,
+			updatedAt: value.updatedAt
+		});
+	});
+	return entries;
+}
+/** Get direct children of a parent, sorted by order. */
+function childrenOf(entries, parentId) {
+	return entries.filter((e) => e.parentId === parentId).sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+}
+/** Get all descendants of an entry. */
+function descendantsOf(entries, id) {
+	const result = [];
+	const visited = /* @__PURE__ */ new Set();
+	function collect(pid) {
+		if (visited.has(pid)) return;
+		visited.add(pid);
+		for (const child of childrenOf(entries, pid)) {
+			result.push(child);
+			collect(child.id);
+		}
+	}
+	collect(id);
+	return result;
+}
+/** Build a nested tree structure for display. */
+function buildTree(entries, rootId, maxDepth, currentDepth = 0, visited = /* @__PURE__ */ new Set()) {
+	if (maxDepth >= 0 && currentDepth >= maxDepth) return [];
+	return childrenOf(entries, rootId).filter((e) => !visited.has(e.id)).map((entry) => {
+		const next = new Set(visited);
+		next.add(entry.id);
+		return {
+			id: entry.id,
+			label: entry.label,
+			type: entry.type,
+			meta: entry.meta,
+			children: buildTree(entries, entry.id, maxDepth, currentDepth + 1, next)
+		};
+	});
+}
+/**
+* Normalize a document ID so the hub/root doc ID is treated as the tree root (null).
+*/
+function normalizeRootId(id, conn) {
+	if (id == null) return null;
+	return id === conn.rootDocId ? null : id;
+}
+/**
+* Resolve a document from parsed args.
+*
+* Resolution order:
+*   1. id=<uuid> — Direct document ID
+*   2. name=<label> — Case-insensitive label match (first match wins)
+*   3. path=<a/b/c> — Resolve by label path from root
+*   4. First positional argument — tries name resolution
+*
+* Returns the document ID or null if not found.
+*/
+function resolveDocument(conn, params, positional) {
+	const treeMap = conn.getTreeMap();
+	if (!treeMap) return null;
+	const entries = readEntries(treeMap);
+	if (params["id"]) {
+		const entry = entries.find((e) => e.id === params["id"]);
+		return entry ? entry.id : null;
+	}
+	const name = params["name"] || params["file"] || positional[0];
+	if (name) {
+		const lower = name.toLowerCase();
+		const match = entries.find((e) => e.label.toLowerCase() === lower);
+		if (match) return match.id;
+		const substring = entries.find((e) => e.label.toLowerCase().includes(lower));
+		if (substring) return substring.id;
+	}
+	if (params["path"]) {
+		const segments = params["path"].split("/").map((s) => s.trim()).filter(Boolean);
+		let currentParent = normalizeRootId(conn.rootDocId, conn);
+		for (const segment of segments) {
+			const lower = segment.toLowerCase();
+			const match = childrenOf(entries, currentParent).find((c) => c.label.toLowerCase() === lower);
+			if (!match) return null;
+			currentParent = match.id;
+		}
+		return currentParent;
+	}
+	return null;
+}
+/** Get the ancestor path labels for a document. */
+function getAncestorPath(entries, docId) {
+	const byId = new Map(entries.map((e) => [e.id, e]));
+	const path = [];
+	let current = byId.get(docId)?.parentId;
+	const visited = /* @__PURE__ */ new Set();
+	while (current && !visited.has(current)) {
+		visited.add(current);
+		const parent = byId.get(current);
+		if (!parent) break;
+		path.unshift(parent.label);
+		current = parent.parentId;
+	}
+	return path;
+}
+
+//#endregion
+//#region packages/cli/src/commands/spaces.ts
+/**
+* spaces, spaces:switch, info commands.
+*/
+registerCommand({
+	name: "info",
+	description: "Show server and space info.",
+	async run(conn) {
+		if (!conn) return "Not connected";
+		const si = conn.serverInfo;
+		if (!si) return "No server info available";
+		const treeMap = conn.getTreeMap();
+		const docCount = treeMap ? readEntries(treeMap).length : 0;
+		const rootProvider = conn.rootProvider;
+		const onlineUsers = rootProvider ? Array.from(rootProvider.awareness.getStates().values()).filter((s) => s.user).length : 0;
+		return [
+			`Server:      ${si.name ?? "—"}`,
+			`URL:         ${conn.config.url}`,
+			`Version:     ${si.version ?? "—"}`,
+			`Protocol:    ${si.protocol_version ?? "—"}`,
+			`Hub Doc:     ${conn.rootDocId ?? "—"}`,
+			`Auth:        ${si.auth_methods?.join(", ") ?? "—"}`,
+			`Registration:${si.registration_allowed ? " open" : " closed"}${si.invite_only ? " (invite only)" : ""}`,
+			`Documents:   ${docCount}`,
+			`Users:       ${onlineUsers} online`
+		].join("\n");
+	}
+});
+registerCommand({
+	name: "spaces",
+	description: "List available spaces/root documents.",
+	usage: "spaces [--format=json|tsv]",
+	async run(conn, args) {
+		if (!conn) return "Not connected";
+		const spaces = conn.spaces;
+		if (!spaces.length) return "No spaces available.";
+		const format = getFormat(args, "text");
+		const active = conn.rootDocId;
+		if (format === "json") return printJson(spaces.map((s) => ({
+			...s,
+			active: s.doc_id === active
+		})));
+		return printTable(spaces.map((s) => [
+			s.doc_id === active ? "▸" : " ",
+			s.doc_id.slice(0, 8) + "…",
+			s.name,
+			s.is_hub ? "hub" : "",
+			s.visibility
+		]), [
+			"",
+			"ID",
+			"NAME",
+			"HUB",
+			"VISIBILITY"
+		]);
+	}
+});
+registerCommand({
+	name: "spaces:switch",
+	aliases: ["switch"],
+	description: "Switch the active space.",
+	usage: "spaces:switch name=<name> | id=<docId>",
+	async run(conn, args) {
+		if (!conn) return "Not connected";
+		const targetName = args.params["name"] || args.positional[0];
+		const targetId = args.params["id"];
+		let docId = null;
+		if (targetId) docId = targetId;
+		else if (targetName) {
+			const lower = targetName.toLowerCase();
+			const space = conn.spaces.find((s) => s.name.toLowerCase() === lower || s.doc_id === targetName);
+			if (space) docId = space.doc_id;
+		}
+		if (!docId) return "Space not found. Use \"abracadabra spaces\" to list available spaces.";
+		await conn.switchSpace(docId);
+		return `Switched to space "${conn.spaces.find((s) => s.doc_id === docId)?.name ?? docId}"`;
+	}
+});
+
+//#endregion
+//#region packages/cli/src/commands/tree.ts
+/**
+* tree, ls, search commands — navigate and explore the document tree.
+*/
+function toTreeNodes(nodes) {
+	return nodes.map((n) => ({
+		label: n.label,
+		type: n.type,
+		children: n.children.length > 0 ? toTreeNodes(n.children) : void 0
+	}));
+}
+registerCommand({
+	name: "tree",
+	aliases: ["t"],
+	description: "Show the full document tree hierarchy.",
+	usage: "tree [id=<docId>] [depth=<n>] [--format=json|tree]",
+	async run(conn, args) {
+		if (!conn) return "Not connected";
+		const treeMap = conn.getTreeMap();
+		if (!treeMap) return "Not connected";
+		const rootId = normalizeRootId(args.params["id"] || args.positional[0] || conn.rootDocId, conn);
+		const maxDepth = args.params["depth"] ? parseInt(args.params["depth"], 10) : -1;
+		const format = getFormat(args, "tree");
+		const tree = buildTree(readEntries(treeMap), rootId, maxDepth);
+		if (format === "json") return printJson(tree);
+		if (tree.length === 0) return "(empty tree)";
+		return (conn.spaces.find((s) => s.doc_id === conn.rootDocId)?.name ?? conn.rootDocId ?? "Workspace") + "\n" + printTree(toTreeNodes(tree));
+	}
+});
+registerCommand({
+	name: "ls",
+	aliases: ["list", "l"],
+	description: "List direct children of a document (defaults to root).",
+	usage: "ls [id=<parentId>] [name=<parentName>] [--format=json|tsv] [--total]",
+	async run(conn, args) {
+		if (!conn) return "Not connected";
+		const treeMap = conn.getTreeMap();
+		if (!treeMap) return "Not connected";
+		let parentId = null;
+		if (args.params["id"] || args.params["name"] || args.params["path"] || args.positional[0]) {
+			parentId = resolveDocument(conn, args.params, args.positional);
+			if (!parentId && (args.params["id"] || args.params["name"] || args.params["path"])) return "Document not found.";
+		}
+		const targetId = normalizeRootId(parentId || conn.rootDocId, conn);
+		const children = childrenOf(readEntries(treeMap), targetId);
+		if (args.flags.has("total")) return String(children.length);
+		if (getFormat(args, "text") === "json") return printJson(children);
+		if (children.length === 0) return "(no children)";
+		return printTable(children.map((c) => [
+			c.id.slice(0, 8) + "…",
+			c.label,
+			c.type ?? "—",
+			relativeTime(c.updatedAt)
+		]), [
+			"ID",
+			"LABEL",
+			"TYPE",
+			"UPDATED"
+		]);
+	}
+});
+registerCommand({
+	name: "search",
+	aliases: ["find", "s"],
+	description: "Search documents by label across the tree.",
+	usage: "search query=<text> [id=<rootId>] [--format=json|tsv] [--total]",
+	async run(conn, args) {
+		if (!conn) return "Not connected";
+		const treeMap = conn.getTreeMap();
+		if (!treeMap) return "Not connected";
+		const query = args.params["query"] || args.positional[0];
+		if (!query) return "Missing required parameter: query=<text>";
+		const entries = readEntries(treeMap);
+		const lowerQuery = query.toLowerCase();
+		const matches = entries.filter((e) => e.label.toLowerCase().includes(lowerQuery));
+		if (args.flags.has("total")) return String(matches.length);
+		const format = getFormat(args, "text");
+		if (matches.length === 0) return `No documents found matching "${query}".`;
+		const results = matches.map((entry) => ({
+			id: entry.id,
+			label: entry.label,
+			type: entry.type,
+			path: getAncestorPath(entries, entry.id)
+		}));
+		if (format === "json") return printJson(results);
+		return printTable(results.map((r) => [
+			r.path.length > 0 ? r.path.join(" / ") + " / " + r.label : r.label,
+			r.label,
+			r.type ?? "—"
+		]), [
+			"PATH",
+			"LABEL",
+			"TYPE"
+		]);
+	}
+});
+
+//#endregion
+//#region packages/mcp/src/converters/yjsToMarkdown.ts
+/**
+* Y.XmlFragment → Markdown serializer.
+* Walks the TipTap document structure and produces markdown text.
+*/
+function deltaToMarkdown(delta) {
+	return delta.map((op) => {
+		let text = op.insert;
+		if (!op.attributes) return text;
+		const a = op.attributes;
+		if (a.code) text = `\`${text}\``;
+		if (a.bold) text = `**${text}**`;
+		if (a.italic) text = `*${text}*`;
+		if (a.strike) text = `~~${text}~~`;
+		if (a.link?.href) text = `[${text}](${a.link.href})`;
+		if (a.badge) text = `:badge[${a.badge.label || text}]`;
+		if (a.kbd) text = `:kbd{value="${a.kbd.value || text}"}`;
+		if (a.proseIcon) text = `:icon{name="${a.proseIcon.name}"}`;
+		return text;
+	}).join("");
+}
+function xmlTextToMarkdown(xmlText) {
+	return deltaToMarkdown(xmlText.toDelta());
+}
+function elementTextContent(el) {
+	const parts = [];
+	for (let i = 0; i < el.length; i++) {
+		const child = el.get(i);
+		if (child instanceof yjs.XmlText) parts.push(xmlTextToMarkdown(child));
+		else if (child instanceof yjs.XmlElement) parts.push(elementTextContent(child));
+	}
+	return parts.join("");
+}
+function serializeElement(el, indent = "") {
+	switch (el.nodeName) {
+		case "documentHeader":
+		case "documentMeta": return "";
+		case "heading": {
+			const level = Number(el.getAttribute("level")) || 1;
+			return `${"#".repeat(level)} ${elementTextContent(el)}`;
+		}
+		case "paragraph": return elementTextContent(el);
+		case "bulletList": return serializeList(el, "bullet", indent);
+		case "orderedList": return serializeList(el, "ordered", indent);
+		case "taskList": return serializeTaskList(el, indent);
+		case "codeBlock": return `\`\`\`${el.getAttribute("language") || ""}\n${elementTextContent(el)}\n\`\`\``;
+		case "blockquote": {
+			const lines = [];
+			for (let i = 0; i < el.length; i++) {
+				const child = el.get(i);
+				if (child instanceof yjs.XmlElement) lines.push(serializeElement(child, indent));
+			}
+			return lines.map((l) => `> ${l}`).join("\n");
+		}
+		case "horizontalRule": return "---";
+		case "table": return serializeTable(el);
+		case "docEmbed": {
+			const docId = el.getAttribute("docId");
+			return docId ? `![[${docId}]]` : "";
+		}
+		case "svgEmbed": {
+			const svg = el.getAttribute("svg") || "";
+			const svgTitle = el.getAttribute("title") || "";
+			if (!svg) return "";
+			return `\`\`\`svg${svgTitle ? ` ${svgTitle}` : ""}\n${svg}\n\`\`\``;
+		}
+		case "image": {
+			const src = el.getAttribute("src") || "";
+			const alt = el.getAttribute("alt") || "";
+			const w = el.getAttribute("width");
+			const h = el.getAttribute("height");
+			let attrs = "";
+			if (w || h) {
+				const parts = [];
+				if (w) parts.push(`width="${w}"`);
+				if (h) parts.push(`height="${h}"`);
+				attrs = `{${parts.join(" ")}}`;
+			}
+			return `![${alt}](${src})${attrs}`;
+		}
+		case "callout": return `::${el.getAttribute("type") || "note"}\n${serializeChildren(el, indent)}\n::`;
+		case "collapsible": {
+			const label = el.getAttribute("label") || "Details";
+			const open = el.getAttribute("open");
+			const props = [`label="${label}"`];
+			if (open === true || open === "true") props.push("open=\"true\"");
+			const inner = serializeChildren(el, indent);
+			return `::collapsible{${props.join(" ")}}\n${inner}\n::`;
+		}
+		case "steps": return `::steps\n${serializeChildren(el, indent)}\n::`;
+		case "card": {
+			const title = el.getAttribute("title") || "";
+			const icon = el.getAttribute("icon") || "";
+			const to = el.getAttribute("to") || "";
+			const props = [];
+			if (title) props.push(`title="${title}"`);
+			if (icon) props.push(`icon="${icon}"`);
+			if (to) props.push(`to="${to}"`);
+			const inner = serializeChildren(el, indent);
+			return `::card{${props.join(" ")}}\n${inner}\n::`;
+		}
+		case "cardGroup": return `::card-group\n${serializeChildren(el, indent)}\n::`;
+		case "codeCollapse": return `::code-collapse\n${serializeChildren(el, indent)}\n::`;
+		case "codeGroup": return `::code-group\n${serializeChildren(el, indent)}\n::`;
+		case "codePreview": return `::code-preview\n${serializeChildren(el, indent)}\n::`;
+		case "codeTree": return `::code-tree{files="${el.getAttribute("files") || "[]"}"}\n::`;
+		case "accordion": return serializeSlottedComponent(el, "accordion", "accordionItem", "item");
+		case "tabs": return serializeSlottedComponent(el, "tabs", "tabsItem", "tab");
+		case "field": {
+			const fieldName = el.getAttribute("name") || "";
+			const fieldType = el.getAttribute("type") || "string";
+			const required = el.getAttribute("required");
+			const props = [];
+			if (fieldName) props.push(`name="${fieldName}"`);
+			props.push(`type="${fieldType}"`);
+			if (required === true || required === "true") props.push("required=\"true\"");
+			const inner = serializeChildren(el, indent);
+			return `::field{${props.join(" ")}}\n${inner}\n::`;
+		}
+		case "fieldGroup": return `::field-group\n${serializeChildren(el, indent)}\n::`;
+		default: return serializeChildren(el, indent);
+	}
+}
+function serializeList(el, type, indent) {
+	const lines = [];
+	for (let i = 0; i < el.length; i++) {
+		const item = el.get(i);
+		if (item instanceof yjs.XmlElement && item.nodeName === "listItem") {
+			const prefix = type === "bullet" ? "- " : `${i + 1}. `;
+			const content = elementTextContent(item);
+			lines.push(`${indent}${prefix}${content}`);
+		}
+	}
+	return lines.join("\n");
+}
+function serializeTaskList(el, indent) {
+	const lines = [];
+	for (let i = 0; i < el.length; i++) {
+		const item = el.get(i);
+		if (item instanceof yjs.XmlElement && item.nodeName === "taskItem") {
+			const checked = item.getAttribute("checked");
+			const marker = checked === true || checked === "true" ? "[x]" : "[ ]";
+			const content = elementTextContent(item);
+			lines.push(`${indent}- ${marker} ${content}`);
+		}
+	}
+	return lines.join("\n");
+}
+function serializeTable(el) {
+	const rows = [];
+	for (let i = 0; i < el.length; i++) {
+		const row = el.get(i);
+		if (!(row instanceof yjs.XmlElement) || row.nodeName !== "tableRow") continue;
+		const cells = [];
+		for (let j = 0; j < row.length; j++) {
+			const cell = row.get(j);
+			if (cell instanceof yjs.XmlElement) cells.push(elementTextContent(cell));
+		}
+		rows.push(cells);
+	}
+	if (!rows.length) return "";
+	const headerRow = rows[0];
+	const lines = [`| ${headerRow.join(" | ")} |`];
+	lines.push(`| ${headerRow.map(() => "---").join(" | ")} |`);
+	for (let i = 1; i < rows.length; i++) lines.push(`| ${rows[i].join(" | ")} |`);
+	return lines.join("\n");
+}
+function serializeSlottedComponent(el, componentName, childNodeName, slotName) {
+	const parts = [`::${componentName}`];
+	for (let i = 0; i < el.length; i++) {
+		const child = el.get(i);
+		if (!(child instanceof yjs.XmlElement) || child.nodeName !== childNodeName) continue;
+		const label = child.getAttribute("label") || `Item ${i + 1}`;
+		const icon = child.getAttribute("icon") || "";
+		const props = [`label="${label}"`];
+		if (icon) props.push(`icon="${icon}"`);
+		parts.push(`#${slotName}{${props.join(" ")}}`);
+		const inner = serializeChildren(child, "");
+		if (inner) parts.push(inner);
+	}
+	parts.push("::");
+	return parts.join("\n");
+}
+function serializeChildren(el, indent) {
+	const parts = [];
+	for (let i = 0; i < el.length; i++) {
+		const child = el.get(i);
+		if (child instanceof yjs.XmlElement) {
+			const serialized = serializeElement(child, indent);
+			if (serialized) parts.push(serialized);
+		} else if (child instanceof yjs.XmlText) {
+			const text = xmlTextToMarkdown(child);
+			if (text) parts.push(text);
+		}
+	}
+	return parts.join("\n\n");
+}
+/**
+* Converts a Y.XmlFragment (TipTap document) to markdown.
+* Extracts the title from the documentHeader element.
+*
+* @returns `{ title, markdown }` where title is the H1/header text
+*/
+function yjsToMarkdown(fragment) {
+	let title = "Untitled";
+	const bodyParts = [];
+	for (let i = 0; i < fragment.length; i++) {
+		const child = fragment.get(i);
+		if (!(child instanceof yjs.XmlElement)) continue;
+		if (child.nodeName === "documentHeader") {
+			title = elementTextContent(child) || "Untitled";
+			continue;
+		}
+		if (child.nodeName === "documentMeta") continue;
+		const serialized = serializeElement(child);
+		if (serialized !== "") bodyParts.push(serialized);
+	}
+	return {
+		title,
+		markdown: bodyParts.join("\n\n")
+	};
+}
+
+//#endregion
+//#region packages/mcp/src/converters/markdownToYjs.ts
+/**
+* Markdown → Y.js converter.
+* Ported from cou-sh/app/utils/markdownToYjs.ts with Vue dependency removed.
+*/
+function parseInlineArray(raw) {
+	return raw.slice(1, -1).split(",").map((s) => s.trim()).filter(Boolean);
+}
+function parseFrontmatter(markdown) {
+	const noResult = {
+		meta: {},
+		body: markdown
+	};
+	const match = markdown.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
+	if (!match) return noResult;
+	const yamlBlock = match[1];
+	const body = markdown.slice(match[0].length);
+	const raw = {};
+	const lines = yamlBlock.split("\n");
+	let i = 0;
+	while (i < lines.length) {
+		const line = lines[i];
+		const blockSeqKey = line.match(/^(\w[\w-]*):\s*$/);
+		if (blockSeqKey && i + 1 < lines.length && /^\s+-\s/.test(lines[i + 1])) {
+			const key = blockSeqKey[1];
+			const items = [];
+			i++;
+			while (i < lines.length && /^\s+-\s/.test(lines[i])) {
+				items.push(lines[i].replace(/^\s+-\s/, "").trim());
+				i++;
+			}
+			raw[key] = items;
+			continue;
+		}
+		const kvMatch = line.match(/^(\w[\w-]*):\s*(.*)$/);
+		if (kvMatch) {
+			const key = kvMatch[1];
+			const val = kvMatch[2].trim();
+			if (val.startsWith("[") && val.endsWith("]")) raw[key] = parseInlineArray(val);
+			else raw[key] = val;
+		}
+		i++;
+	}
+	const meta = {};
+	const getStr = (keys) => {
+		for (const k of keys) {
+			const v = raw[k];
+			if (typeof v === "string" && v) return v;
+		}
+	};
+	if (raw["tags"]) meta.tags = Array.isArray(raw["tags"]) ? raw["tags"] : [raw["tags"]];
+	const color = getStr(["color"]);
+	if (color) meta.color = color;
+	const icon = getStr(["icon"]);
+	if (icon) meta.icon = icon;
+	const status = getStr(["status"]);
+	if (status) meta.status = status;
+	const priorityRaw = getStr(["priority"]);
+	if (priorityRaw !== void 0) meta.priority = {
+		low: 1,
+		medium: 2,
+		high: 3,
+		urgent: 4
+	}[priorityRaw.toLowerCase()] ?? (Number(priorityRaw) || 0);
+	const checkedRaw = raw["checked"] ?? raw["done"];
+	if (checkedRaw !== void 0) meta.checked = checkedRaw === "true" || checkedRaw === true;
+	const dateStart = getStr(["date", "created"]);
+	if (dateStart) meta.dateStart = dateStart;
+	const dateEnd = getStr(["due"]);
+	if (dateEnd) meta.dateEnd = dateEnd;
+	const subtitle = getStr(["description", "subtitle"]);
+	if (subtitle) meta.subtitle = subtitle;
+	const url = getStr(["url"]);
+	if (url) meta.url = url;
+	const email = getStr(["email"]);
+	if (email) meta.email = email;
+	const phone = getStr(["phone"]);
+	if (phone) meta.phone = phone;
+	const ratingRaw = getStr(["rating"]);
+	if (ratingRaw !== void 0) {
+		const n = Number(ratingRaw);
+		if (!Number.isNaN(n)) meta.rating = Math.min(5, Math.max(0, n));
+	}
+	const datetimeStart = getStr(["datetimeStart"]);
+	if (datetimeStart) meta.datetimeStart = datetimeStart;
+	const datetimeEnd = getStr(["datetimeEnd"]);
+	if (datetimeEnd) meta.datetimeEnd = datetimeEnd;
+	const allDayRaw = raw["allDay"];
+	if (allDayRaw !== void 0) meta.allDay = allDayRaw === "true" || allDayRaw === true;
+	const geoLatRaw = getStr(["geoLat"]);
+	if (geoLatRaw !== void 0) {
+		const n = Number(geoLatRaw);
+		if (!Number.isNaN(n)) meta.geoLat = n;
+	}
+	const geoLngRaw = getStr(["geoLng"]);
+	if (geoLngRaw !== void 0) {
+		const n = Number(geoLngRaw);
+		if (!Number.isNaN(n)) meta.geoLng = n;
+	}
+	const geoType = getStr(["geoType"]);
+	if (geoType && (geoType === "marker" || geoType === "line" || geoType === "measure")) meta.geoType = geoType;
+	const geoDescription = getStr(["geoDescription"]);
+	if (geoDescription) meta.geoDescription = geoDescription;
+	const numberRaw = getStr(["number"]);
+	if (numberRaw !== void 0) {
+		const n = Number(numberRaw);
+		if (!Number.isNaN(n)) meta.number = n;
+	}
+	const unit = getStr(["unit"]);
+	if (unit) meta.unit = unit;
+	const note = getStr(["note"]);
+	if (note) meta.note = note;
+	return {
+		title: typeof raw["title"] === "string" ? raw["title"] : void 0,
+		meta,
+		body
+	};
+}
+function parseInline(text) {
+	const stripped = text.replace(/\{lang="[^"]*"\}/g, "").replace(/:(?!badge|icon|kbd)(\w[\w-]*)\[([^\]]*)\](\{[^}]*\})?/g, "$2").replace(/:(?!badge|icon|kbd)(\w[\w-]*)(\{[^}]*\})/g, "");
+	const tokens = [];
+	const re = /:badge\[([^\]]*)\](\{[^}]*\})?|:icon\{([^}]*)\}|:kbd\{([^}]*)\}|!?\[\[([^\]|]+?)(?:\|([^\]]+?))?\]\]|~~(.+?)~~|\*\*(.+?)\*\*|\*(.+?)\*|_(.+?)_|`(.+?)`|\[(.+?)\]\((.+?)\)/g;
+	let lastIndex = 0;
+	let match;
+	while ((match = re.exec(stripped)) !== null) {
+		if (match.index > lastIndex) tokens.push({ text: stripped.slice(lastIndex, match.index) });
+		if (match[1] !== void 0) {
+			const badgeProps = parseMdcProps(match[2]);
+			tokens.push({
+				text: match[1] || "Badge",
+				attrs: { badge: {
+					label: match[1] || "Badge",
+					color: badgeProps["color"] || "neutral",
+					variant: badgeProps["variant"] || "subtle"
+				} }
+			});
+		} else if (match[3] !== void 0) {
+			const iconProps = parseMdcProps(`{${match[3]}}`);
+			tokens.push({
+				text: "​",
+				attrs: { proseIcon: { name: iconProps["name"] || "i-lucide-star" } }
+			});
+		} else if (match[4] !== void 0) {
+			const kbdProps = parseMdcProps(`{${match[4]}}`);
+			tokens.push({
+				text: kbdProps["value"] || "",
+				attrs: { kbd: { value: kbdProps["value"] || "" } }
+			});
+		} else if (match[5] !== void 0) {
+			const docId = match[5];
+			const displayText = match[6] ?? docId;
+			tokens.push({
+				text: displayText,
+				attrs: { link: { href: `/doc/${docId}` } }
+			});
+		} else if (match[7] !== void 0) tokens.push({
+			text: match[7],
+			attrs: { strike: true }
+		});
+		else if (match[8] !== void 0) tokens.push({
+			text: match[8],
+			attrs: { bold: true }
+		});
+		else if (match[9] !== void 0) tokens.push({
+			text: match[9],
+			attrs: { italic: true }
+		});
+		else if (match[10] !== void 0) tokens.push({
+			text: match[10],
+			attrs: { italic: true }
+		});
+		else if (match[11] !== void 0) tokens.push({
+			text: match[11],
+			attrs: { code: true }
+		});
+		else if (match[12] !== void 0 && match[13] !== void 0) tokens.push({
+			text: match[12],
+			attrs: { link: { href: match[13] } }
+		});
+		lastIndex = match.index + match[0].length;
+	}
+	if (lastIndex < stripped.length) tokens.push({ text: stripped.slice(lastIndex) });
+	return tokens.filter((t) => t.text.length > 0);
+}
+function parseTableRow(line) {
+	const parts = line.split("|");
+	return parts.slice(1, parts.length - 1).map((c) => c.trim());
+}
+function isTableSeparator(line) {
+	return /^\|[\s|:-]+\|$/.test(line.trim());
+}
+function extractFencedCode(lines) {
+	const result = [];
+	let i = 0;
+	while (i < lines.length) {
+		const fenceMatch = lines[i].match(/^(`{3,})(\w*)/);
+		if (fenceMatch) {
+			const fence = fenceMatch[1];
+			const lang = fenceMatch[2] ?? "";
+			const codeLines = [];
+			i++;
+			while (i < lines.length && !lines[i].startsWith(fence)) {
+				codeLines.push(lines[i]);
+				i++;
+			}
+			i++;
+			result.push({
+				type: "codeBlock",
+				lang,
+				code: codeLines.join("\n")
+			});
+			continue;
+		}
+		i++;
+	}
+	return result;
+}
+function parseMdcProps(propsStr) {
+	if (!propsStr) return {};
+	const result = {};
+	const re = /(\w[\w-]*)="([^"]*)"/g;
+	let m;
+	while ((m = re.exec(propsStr)) !== null) result[m[1]] = m[2];
+	return result;
+}
+function parseMdcChildren(innerLines, slotPrefix) {
+	const items = [];
+	let current = null;
+	const slotRe = new RegExp(`^#${slotPrefix}(\\{[^}]*\\})?\\s*$`);
+	for (const line of innerLines) {
+		const slotMatch = line.match(slotRe);
+		if (slotMatch) {
+			if (current) items.push(current);
+			const props = parseMdcProps(slotMatch[1]);
+			current = {
+				label: props["label"] || props["title"] || `Item ${items.length + 1}`,
+				icon: props["icon"] || "",
+				lines: []
+			};
+			continue;
+		}
+		if (current) current.lines.push(line);
+		else if (!items.length && !current) current = {
+			label: `Item 1`,
+			icon: "",
+			lines: [line]
+		};
+	}
+	if (current) items.push(current);
+	return items.map((item) => ({
+		label: item.label,
+		icon: item.icon,
+		innerBlocks: parseBlocks(item.lines.join("\n"))
+	}));
+}
+const TASK_RE = /^[-*+]\s+\[([ xX])\]\s+(.*)/;
+function parseBlocks(markdown) {
+	const rawLines = markdown.split("\n");
+	let firstContentLine = 0;
+	while (firstContentLine < rawLines.length) {
+		const l = rawLines[firstContentLine];
+		if (l.trim() === "" || /^import\s/.test(l) || /^export\s/.test(l)) firstContentLine++;
+		else break;
+	}
+	const stripped = rawLines.slice(firstContentLine).join("\n");
+	const blocks = [];
+	const lines = stripped.split("\n");
+	let i = 0;
+	while (i < lines.length) {
+		const line = lines[i];
+		const fenceBlockMatch = line.match(/^(`{3,})(.*)$/);
+		if (fenceBlockMatch) {
+			const fence = fenceBlockMatch[1];
+			const lang = fenceBlockMatch[2].trim().replace(/\{[^}]*\}$/, "").replace(/\s*\[.*\]$/, "").trim();
+			const codeLines = [];
+			i++;
+			while (i < lines.length && !lines[i].startsWith(fence)) {
+				codeLines.push(lines[i]);
+				i++;
+			}
+			i++;
+			if (lang === "svg" || lang.startsWith("svg ")) {
+				const svgTitle = lang === "svg" ? "" : lang.slice(4).trim();
+				blocks.push({
+					type: "svgEmbed",
+					svg: codeLines.join("\n"),
+					title: svgTitle
+				});
+			} else blocks.push({
+				type: "codeBlock",
+				lang,
+				code: codeLines.join("\n")
+			});
+			continue;
+		}
+		const headingMatch = line.match(/^(#{1,6})\s+(.*)/);
+		if (headingMatch) {
+			blocks.push({
+				type: "heading",
+				level: headingMatch[1].length,
+				text: headingMatch[2].trim()
+			});
+			i++;
+			continue;
+		}
+		if (/^[-*_]{3,}\s*$/.test(line)) {
+			blocks.push({ type: "hr" });
+			i++;
+			continue;
+		}
+		const docEmbedMatch = line.match(/^!\[\[([^\]|]+?)(?:\|[^\]]*?)?\]\]\s*$/);
+		if (docEmbedMatch) {
+			blocks.push({
+				type: "docEmbed",
+				docId: docEmbedMatch[1]
+			});
+			i++;
+			continue;
+		}
+		const imgMatch = line.match(/^!\[([^\]]*)\]\(([^)]+)\)(\{[^}]*\})?\s*$/);
+		if (imgMatch) {
+			const alt = imgMatch[1] ?? "";
+			const src = imgMatch[2] ?? "";
+			const attrs = parseMdcProps(imgMatch[3]);
+			blocks.push({
+				type: "image",
+				src,
+				alt,
+				width: attrs["width"],
+				height: attrs["height"]
+			});
+			i++;
+			continue;
+		}
+		if (line.startsWith("> ") || line === ">") {
+			const bqLines = [];
+			while (i < lines.length && (lines[i].startsWith("> ") || lines[i] === ">")) {
+				bqLines.push(lines[i].replace(/^>\s?/, ""));
+				i++;
+			}
+			blocks.push({
+				type: "blockquote",
+				lines: bqLines
+			});
+			continue;
+		}
+		if (/^\s*\|/.test(line)) {
+			const tableLines = [];
+			while (i < lines.length && /^\s*\|/.test(lines[i])) {
+				tableLines.push(lines[i]);
+				i++;
+			}
+			if (tableLines.length >= 2 && isTableSeparator(tableLines[1])) {
+				const headerRow = parseTableRow(tableLines[0]);
+				const dataRows = tableLines.slice(2).filter((l) => !isTableSeparator(l)).map(parseTableRow);
+				blocks.push({
+					type: "table",
+					headerRow,
+					dataRows
+				});
+			} else for (const l of tableLines) blocks.push({
+				type: "paragraph",
+				text: l
+			});
+			continue;
+		}
+		const MDC_OPEN = /^\s*(:{2,})(\w[\w-]*)(\{[^}]*\})?\s*$/;
+		if (MDC_OPEN.test(line)) {
+			const colons = line.match(/^\s*(:+)/)?.[1]?.length ?? 2;
+			const componentName = line.match(/^\s*:{2,}(\w[\w-]*)/)?.[1] ?? "";
+			const innerLines = [];
+			i++;
+			while (i < lines.length) {
+				const l = lines[i];
+				if (new RegExp(`^\\s*:{${colons}}\\s*$`).test(l)) {
+					i++;
+					break;
+				}
+				const innerFence = l.match(/^(\s*`{3,})/);
+				if (innerFence) {
+					const fenceStr = innerFence[1].trimStart();
+					innerLines.push(l);
+					i++;
+					while (i < lines.length && !lines[i].trimStart().startsWith(fenceStr)) {
+						innerLines.push(lines[i]);
+						i++;
+					}
+					if (i < lines.length) {
+						innerLines.push(lines[i]);
+						i++;
+					}
+					continue;
+				}
+				innerLines.push(l);
+				i++;
+			}
+			const nonBlank = innerLines.filter((l) => l.trim().length > 0);
+			if (nonBlank.length) {
+				const minIndent = Math.min(...nonBlank.map((l) => l.match(/^(\s*)/)?.[1]?.length ?? 0));
+				if (minIndent > 0) for (let j = 0; j < innerLines.length; j++) innerLines[j] = innerLines[j].slice(Math.min(minIndent, innerLines[j].length));
+			}
+			let contentStart = 0;
+			if (innerLines[0]?.trim() === "---") {
+				const fmEnd = innerLines.findIndex((l, idx) => idx > 0 && l.trim() === "---");
+				if (fmEnd !== -1) contentStart = fmEnd + 1;
+			}
+			const contentLines = innerLines.slice(contentStart);
+			const defaultSlotLines = [];
+			const codeSlotLines = [];
+			let currentSlot = "default";
+			for (const l of contentLines) {
+				if (/^#code\s*$/.test(l)) {
+					currentSlot = "code";
+					continue;
+				}
+				if (/^#\w+/.test(l) && !/^#{2,}\s/.test(l)) {
+					currentSlot = "other";
+					continue;
+				}
+				if (currentSlot === "default") defaultSlotLines.push(l);
+				else if (currentSlot === "code") codeSlotLines.push(l);
+			}
+			const innerBlocks = parseBlocks(defaultSlotLines.join("\n"));
+			const codeBlocks = extractFencedCode(codeSlotLines);
+			if (new Set([
+				"tip",
+				"note",
+				"info",
+				"warning",
+				"caution",
+				"danger",
+				"callout",
+				"alert"
+			]).has(componentName.toLowerCase())) blocks.push({
+				type: "callout",
+				calloutType: componentName.toLowerCase(),
+				innerBlocks
+			});
+			else {
+				const mdcProps = parseMdcProps(line.match(MDC_OPEN)?.[3]);
+				const lc = componentName.toLowerCase();
+				if (lc === "collapsible") blocks.push({
+					type: "collapsible",
+					label: mdcProps["label"] || "Details",
+					open: mdcProps["open"] === "true",
+					innerBlocks
+				});
+				else if (lc === "steps") blocks.push({
+					type: "steps",
+					innerBlocks
+				});
+				else if (lc === "card") blocks.push({
+					type: "card",
+					title: mdcProps["title"] || "",
+					icon: mdcProps["icon"] || "",
+					to: mdcProps["to"] || "",
+					innerBlocks
+				});
+				else if (lc === "card-group") {
+					const cards = innerBlocks.filter((b) => b.type === "card");
+					if (cards.length) blocks.push({
+						type: "cardGroup",
+						cards
+					});
+					else blocks.push(...innerBlocks);
+				} else if (lc === "code-collapse") blocks.push({
+					type: "codeCollapse",
+					codeBlocks: codeBlocks.length ? codeBlocks : innerBlocks.filter((b) => b.type === "codeBlock")
+				});
+				else if (lc === "code-group") {
+					const allCode = [...innerBlocks.filter((b) => b.type === "codeBlock"), ...codeBlocks];
+					blocks.push({
+						type: "codeGroup",
+						codeBlocks: allCode
+					});
+				} else if (lc === "code-preview") blocks.push({
+					type: "codePreview",
+					innerBlocks,
+					codeBlocks
+				});
+				else if (lc === "code-tree") blocks.push({
+					type: "codeTree",
+					files: mdcProps["files"] || "[]"
+				});
+				else if (lc === "accordion") {
+					const items = parseMdcChildren(contentLines, "item");
+					if (items.length) blocks.push({
+						type: "accordion",
+						items
+					});
+					else blocks.push({
+						type: "accordion",
+						items: [{
+							label: "Item 1",
+							icon: "",
+							innerBlocks
+						}]
+					});
+				} else if (lc === "tabs") {
+					const items = parseMdcChildren(contentLines, "tab");
+					if (items.length) blocks.push({
+						type: "tabs",
+						items
+					});
+					else blocks.push({
+						type: "tabs",
+						items: [{
+							label: "Tab 1",
+							icon: "",
+							innerBlocks
+						}]
+					});
+				} else if (lc === "field") blocks.push({
+					type: "field",
+					name: mdcProps["name"] || "",
+					fieldType: mdcProps["type"] || "string",
+					required: mdcProps["required"] === "true",
+					innerBlocks
+				});
+				else if (lc === "field-group") {
+					const fields = innerBlocks.filter((b) => b.type === "field");
+					if (fields.length) blocks.push({
+						type: "fieldGroup",
+						fields
+					});
+					else blocks.push(...innerBlocks);
+				} else {
+					blocks.push(...innerBlocks);
+					blocks.push(...codeBlocks);
+				}
+			}
+			continue;
+		}
+		if (TASK_RE.test(line)) {
+			const items = [];
+			while (i < lines.length && TASK_RE.test(lines[i])) {
+				const m = lines[i].match(TASK_RE);
+				items.push({
+					checked: m[1].toLowerCase() === "x",
+					text: m[2]
+				});
+				i++;
+			}
+			blocks.push({
+				type: "taskList",
+				items
+			});
+			continue;
+		}
+		if (/^[-*+]\s+/.test(line)) {
+			const items = [];
+			while (i < lines.length && /^[-*+]\s+/.test(lines[i]) && !TASK_RE.test(lines[i])) {
+				items.push(lines[i].replace(/^[-*+]\s+/, ""));
+				i++;
+			}
+			if (items.length) {
+				blocks.push({
+					type: "bulletList",
+					items
+				});
+				continue;
+			}
+		}
+		if (/^\d+\.\s+/.test(line)) {
+			const items = [];
+			while (i < lines.length && /^\d+\.\s+/.test(lines[i])) {
+				items.push(lines[i].replace(/^\d+\.\s+/, ""));
+				i++;
+			}
+			blocks.push({
+				type: "orderedList",
+				items
+			});
+			continue;
+		}
+		if (line.trim() === "") {
+			i++;
+			continue;
+		}
+		const paraLines = [];
+		while (i < lines.length && lines[i].trim() !== "" && !/^(#{1,6}\s|[-*+]\s|\d+\.\s|>|`{3,}|\s*\||[-*_]{3,}\s*$|\s*:{2,}\w)/.test(lines[i])) {
+			paraLines.push(lines[i]);
+			i++;
+		}
+		if (paraLines.length) blocks.push({
+			type: "paragraph",
+			text: paraLines.join(" ")
+		});
+	}
+	return blocks;
+}
+function fillTextInto(el, tokens) {
+	const filtered = tokens.filter((t) => t.text.length > 0);
+	if (!filtered.length) return;
+	const xtNodes = filtered.map(() => new yjs.XmlText());
+	el.insert(0, xtNodes);
+	filtered.forEach((tok, i) => {
+		if (tok.attrs) xtNodes[i].insert(0, tok.text, tok.attrs);
+		else xtNodes[i].insert(0, tok.text);
+	});
+}
+function blockElName(b) {
+	switch (b.type) {
+		case "heading": return "heading";
+		case "paragraph": return "paragraph";
+		case "bulletList": return "bulletList";
+		case "orderedList": return "orderedList";
+		case "taskList": return "taskList";
+		case "codeBlock": return "codeBlock";
+		case "blockquote": return "blockquote";
+		case "table": return "table";
+		case "hr": return "horizontalRule";
+		case "callout": return "callout";
+		case "collapsible": return "collapsible";
+		case "steps": return "steps";
+		case "card": return "card";
+		case "cardGroup": return "cardGroup";
+		case "codeCollapse": return "codeCollapse";
+		case "codeGroup": return "codeGroup";
+		case "codePreview": return "codePreview";
+		case "codeTree": return "codeTree";
+		case "accordion": return "accordion";
+		case "tabs": return "tabs";
+		case "field": return "field";
+		case "fieldGroup": return "fieldGroup";
+		case "image": return "image";
+		case "docEmbed": return "docEmbed";
+		case "svgEmbed": return "svgEmbed";
+	}
+}
+function fillBlock(el, block) {
+	switch (block.type) {
+		case "heading":
+			el.setAttribute("level", block.level);
+			fillTextInto(el, parseInline(block.text));
+			break;
+		case "paragraph":
+			fillTextInto(el, parseInline(block.text));
+			break;
+		case "bulletList":
+		case "orderedList": {
+			const listItemEls = block.items.map(() => new yjs.XmlElement("listItem"));
+			el.insert(0, listItemEls);
+			block.items.forEach((text, i) => {
+				const paraEl = new yjs.XmlElement("paragraph");
+				listItemEls[i].insert(0, [paraEl]);
+				fillTextInto(paraEl, parseInline(text));
+			});
+			break;
+		}
+		case "taskList": {
+			const taskItemEls = block.items.map(() => new yjs.XmlElement("taskItem"));
+			el.insert(0, taskItemEls);
+			block.items.forEach((item, i) => {
+				taskItemEls[i].setAttribute("checked", item.checked);
+				const paraEl = new yjs.XmlElement("paragraph");
+				taskItemEls[i].insert(0, [paraEl]);
+				fillTextInto(paraEl, parseInline(item.text));
+			});
+			break;
+		}
+		case "codeBlock": {
+			if (block.lang) el.setAttribute("language", block.lang);
+			const xt = new yjs.XmlText();
+			el.insert(0, [xt]);
+			xt.insert(0, block.code);
+			break;
+		}
+		case "blockquote": {
+			const paraEls = block.lines.map(() => new yjs.XmlElement("paragraph"));
+			el.insert(0, paraEls);
+			block.lines.forEach((line, i) => fillTextInto(paraEls[i], parseInline(line)));
+			break;
+		}
+		case "table": {
+			const headerRowEl = new yjs.XmlElement("tableRow");
+			const dataRowEls = block.dataRows.map(() => new yjs.XmlElement("tableRow"));
+			el.insert(0, [headerRowEl, ...dataRowEls]);
+			const headerCellEls = block.headerRow.map(() => new yjs.XmlElement("tableHeader"));
+			headerRowEl.insert(0, headerCellEls);
+			block.headerRow.forEach((cellText, i) => {
+				const paraEl = new yjs.XmlElement("paragraph");
+				headerCellEls[i].insert(0, [paraEl]);
+				fillTextInto(paraEl, parseInline(cellText));
+			});
+			block.dataRows.forEach((row, ri) => {
+				const cellEls = row.map(() => new yjs.XmlElement("tableCell"));
+				dataRowEls[ri].insert(0, cellEls);
+				row.forEach((cellText, ci) => {
+					const paraEl = new yjs.XmlElement("paragraph");
+					cellEls[ci].insert(0, [paraEl]);
+					fillTextInto(paraEl, parseInline(cellText));
+				});
+			});
+			break;
+		}
+		case "hr": break;
+		case "callout": {
+			el.setAttribute("type", block.calloutType);
+			if (!block.innerBlocks.length) {
+				const paraEl = new yjs.XmlElement("paragraph");
+				el.insert(0, [paraEl]);
+				break;
+			}
+			const innerEls = block.innerBlocks.map((b) => new yjs.XmlElement(blockElName(b)));
+			el.insert(0, innerEls);
+			block.innerBlocks.forEach((b, i) => fillBlock(innerEls[i], b));
+			break;
+		}
+		case "collapsible": {
+			el.setAttribute("label", block.label);
+			el.setAttribute("open", block.open);
+			const inner = block.innerBlocks.length ? block.innerBlocks : [{
+				type: "paragraph",
+				text: ""
+			}];
+			const innerEls = inner.map((b) => new yjs.XmlElement(blockElName(b)));
+			el.insert(0, innerEls);
+			inner.forEach((b, i) => fillBlock(innerEls[i], b));
+			break;
+		}
+		case "steps": {
+			const inner = block.innerBlocks.length ? block.innerBlocks : [{
+				type: "paragraph",
+				text: ""
+			}];
+			const innerEls = inner.map((b) => new yjs.XmlElement(blockElName(b)));
+			el.insert(0, innerEls);
+			inner.forEach((b, i) => fillBlock(innerEls[i], b));
+			break;
+		}
+		case "card": {
+			if (block.title) el.setAttribute("title", block.title);
+			if (block.icon) el.setAttribute("icon", block.icon);
+			if (block.to) el.setAttribute("to", block.to);
+			const inner = block.innerBlocks.length ? block.innerBlocks : [{
+				type: "paragraph",
+				text: ""
+			}];
+			const innerEls = inner.map((b) => new yjs.XmlElement(blockElName(b)));
+			el.insert(0, innerEls);
+			inner.forEach((b, i) => fillBlock(innerEls[i], b));
+			break;
+		}
+		case "cardGroup": {
+			const cardEls = block.cards.map((b) => new yjs.XmlElement(blockElName(b)));
+			el.insert(0, cardEls);
+			block.cards.forEach((b, i) => fillBlock(cardEls[i], b));
+			break;
+		}
+		case "codeCollapse": {
+			const codes = block.codeBlocks.length ? block.codeBlocks : [{
+				type: "codeBlock",
+				lang: "",
+				code: ""
+			}];
+			const codeEl = new yjs.XmlElement("codeBlock");
+			el.insert(0, [codeEl]);
+			fillBlock(codeEl, codes[0]);
+			break;
+		}
+		case "codeGroup": {
+			const codes = block.codeBlocks.length ? block.codeBlocks : [{
+				type: "codeBlock",
+				lang: "",
+				code: ""
+			}];
+			const codeEls = codes.map(() => new yjs.XmlElement("codeBlock"));
+			el.insert(0, codeEls);
+			codes.forEach((b, i) => fillBlock(codeEls[i], b));
+			break;
+		}
+		case "codePreview": {
+			const all = [...block.innerBlocks, ...block.codeBlocks];
+			const inner = all.length ? all : [{
+				type: "paragraph",
+				text: ""
+			}];
+			const innerEls = inner.map((b) => new yjs.XmlElement(blockElName(b)));
+			el.insert(0, innerEls);
+			inner.forEach((b, i) => fillBlock(innerEls[i], b));
+			break;
+		}
+		case "codeTree":
+			el.setAttribute("files", block.files);
+			break;
+		case "accordion": {
+			const itemEls = block.items.map(() => new yjs.XmlElement("accordionItem"));
+			el.insert(0, itemEls);
+			block.items.forEach((item, i) => {
+				itemEls[i].setAttribute("label", item.label);
+				if (item.icon) itemEls[i].setAttribute("icon", item.icon);
+				const inner = item.innerBlocks.length ? item.innerBlocks : [{
+					type: "paragraph",
+					text: ""
+				}];
+				const childEls = inner.map((b) => new yjs.XmlElement(blockElName(b)));
+				itemEls[i].insert(0, childEls);
+				inner.forEach((b, ci) => fillBlock(childEls[ci], b));
+			});
+			break;
+		}
+		case "tabs": {
+			const itemEls = block.items.map(() => new yjs.XmlElement("tabsItem"));
+			el.insert(0, itemEls);
+			block.items.forEach((item, i) => {
+				itemEls[i].setAttribute("label", item.label);
+				if (item.icon) itemEls[i].setAttribute("icon", item.icon);
+				const inner = item.innerBlocks.length ? item.innerBlocks : [{
+					type: "paragraph",
+					text: ""
+				}];
+				const childEls = inner.map((b) => new yjs.XmlElement(blockElName(b)));
+				itemEls[i].insert(0, childEls);
+				inner.forEach((b, ci) => fillBlock(childEls[ci], b));
+			});
+			break;
+		}
+		case "field": {
+			if (block.name) el.setAttribute("name", block.name);
+			el.setAttribute("type", block.fieldType);
+			el.setAttribute("required", block.required);
+			const inner = block.innerBlocks.length ? block.innerBlocks : [{
+				type: "paragraph",
+				text: ""
+			}];
+			const innerEls = inner.map((b) => new yjs.XmlElement(blockElName(b)));
+			el.insert(0, innerEls);
+			inner.forEach((b, i) => fillBlock(innerEls[i], b));
+			break;
+		}
+		case "fieldGroup": {
+			const fieldEls = block.fields.map((b) => new yjs.XmlElement(blockElName(b)));
+			el.insert(0, fieldEls);
+			block.fields.forEach((b, i) => fillBlock(fieldEls[i], b));
+			break;
+		}
+		case "image":
+			el.setAttribute("src", block.src);
+			if (block.alt) el.setAttribute("alt", block.alt);
+			if (block.width) el.setAttribute("width", block.width);
+			if (block.height) el.setAttribute("height", block.height);
+			break;
+		case "docEmbed":
+			el.setAttribute("docId", block.docId);
+			break;
+		case "svgEmbed":
+			el.setAttribute("svg", block.svg);
+			if (block.title) el.setAttribute("title", block.title);
+			break;
+	}
+}
+function populateYDocFromMarkdown(fragment, markdown, fallbackTitle = "Untitled") {
+	const ydoc = fragment.doc;
+	if (!ydoc) {
+		console.warn("[markdownToYjs] fragment has no doc — skipping population");
+		return;
+	}
+	const blocks = parseBlocks(markdown);
+	let title = fallbackTitle;
+	let contentBlocks = blocks;
+	const h1 = blocks.findIndex((b) => b.type === "heading" && b.level === 1);
+	if (h1 !== -1) {
+		title = blocks[h1].text;
+		contentBlocks = blocks.filter((_, i) => i !== h1);
+	}
+	if (!contentBlocks.length) contentBlocks = [{
+		type: "paragraph",
+		text: ""
+	}];
+	ydoc.transact(() => {
+		const headerEl = new yjs.XmlElement("documentHeader");
+		const metaEl = new yjs.XmlElement("documentMeta");
+		const bodyEls = contentBlocks.map((b) => {
+			switch (b.type) {
+				case "heading": return new yjs.XmlElement("heading");
+				case "paragraph": return new yjs.XmlElement("paragraph");
+				case "bulletList": return new yjs.XmlElement("bulletList");
+				case "orderedList": return new yjs.XmlElement("orderedList");
+				case "taskList": return new yjs.XmlElement("taskList");
+				case "codeBlock": return new yjs.XmlElement("codeBlock");
+				case "blockquote": return new yjs.XmlElement("blockquote");
+				case "table": return new yjs.XmlElement("table");
+				case "hr": return new yjs.XmlElement("horizontalRule");
+				case "callout": return new yjs.XmlElement("callout");
+				case "collapsible": return new yjs.XmlElement("collapsible");
+				case "steps": return new yjs.XmlElement("steps");
+				case "card": return new yjs.XmlElement("card");
+				case "cardGroup": return new yjs.XmlElement("cardGroup");
+				case "codeCollapse": return new yjs.XmlElement("codeCollapse");
+				case "codeGroup": return new yjs.XmlElement("codeGroup");
+				case "codePreview": return new yjs.XmlElement("codePreview");
+				case "codeTree": return new yjs.XmlElement("codeTree");
+				case "accordion": return new yjs.XmlElement("accordion");
+				case "tabs": return new yjs.XmlElement("tabs");
+				case "field": return new yjs.XmlElement("field");
+				case "fieldGroup": return new yjs.XmlElement("fieldGroup");
+				case "image": return new yjs.XmlElement("image");
+				case "docEmbed": return new yjs.XmlElement("docEmbed");
+				case "svgEmbed": return new yjs.XmlElement("svgEmbed");
+			}
+		});
+		fragment.insert(0, [
+			headerEl,
+			metaEl,
+			...bodyEls
+		]);
+		const headerXt = new yjs.XmlText();
+		headerEl.insert(0, [headerXt]);
+		headerXt.insert(0, title);
+		contentBlocks.forEach((block, i) => fillBlock(bodyEls[i], block));
+	});
+}
+
+//#endregion
+//#region packages/cli/src/commands/documents.ts
+/**
+* Document CRUD commands: read, create, rename, move, delete, type, doc.
+*/
+/** Safely read a tree map value, converting Y.Map to plain object if needed. */
+function toPlain$1(val) {
+	return val instanceof yjs.Map ? val.toJSON() : val;
+}
+registerCommand({
+	name: "doc",
+	aliases: ["info:doc"],
+	description: "Show document metadata (label, type, meta, dates).",
+	usage: "doc id=<docId> | name=<label> | path=<a/b/c>",
+	async run(conn, args) {
+		if (!conn) return "Not connected";
+		const docId = resolveDocument(conn, args.params, args.positional);
+		if (!docId) return "Document not found. Specify id=, name=, or path= to identify the document.";
+		const treeMap = conn.getTreeMap();
+		if (!treeMap) return "Not connected";
+		const raw = treeMap.get(docId);
+		if (!raw) return `Document ${docId} not found in tree.`;
+		const entry = toPlain$1(raw);
+		const lines = [
+			`id:        ${docId}`,
+			`label:     ${entry.label || "Untitled"}`,
+			`type:      ${entry.type ?? "—"}`,
+			`parent:    ${entry.parentId ?? "(root)"}`,
+			`order:     ${entry.order ?? 0}`,
+			`created:   ${entry.createdAt ? new Date(entry.createdAt).toISOString() : "—"}`,
+			`updated:   ${entry.updatedAt ? new Date(entry.updatedAt).toISOString() : "—"} (${relativeTime(entry.updatedAt)})`
+		];
+		if (entry.meta && Object.keys(entry.meta).length > 0) {
+			lines.push(`meta:`);
+			for (const [k, v] of Object.entries(entry.meta)) lines.push(`  ${k}: ${typeof v === "object" ? JSON.stringify(v) : v}`);
+		}
+		const children = childrenOf(readEntries(treeMap), docId);
+		lines.push(`children:  ${children.length}`);
+		return lines.join("\n");
+	}
+});
+registerCommand({
+	name: "read",
+	aliases: ["cat", "r"],
+	description: "Read document content as markdown.",
+	usage: "read id=<docId> | name=<label> | path=<a/b/c> [--format=json|md]",
+	async run(conn, args) {
+		if (!conn) return "Not connected";
+		const docId = resolveDocument(conn, args.params, args.positional);
+		if (!docId) return "Document not found. Specify id=, name=, or path= to identify the document.";
+		try {
+			const { title, markdown } = yjsToMarkdown((await conn.getChildProvider(docId)).document.getXmlFragment("default"));
+			if (args.flags.has("json") || args.params["format"] === "json") {
+				const treeMap = conn.getTreeMap();
+				let label = title;
+				let type;
+				let meta;
+				let children = [];
+				if (treeMap) {
+					const entry = treeMap.get(docId);
+					if (entry) {
+						label = entry.label || title;
+						type = entry.type;
+						meta = entry.meta;
+					}
+					treeMap.forEach((value, id) => {
+						const v = toPlain$1(value);
+						if (v.parentId === docId) children.push({
+							id,
+							label: v.label || "Untitled",
+							type: v.type
+						});
+					});
+					children.sort((a, b) => {
+						const va = treeMap.get(a.id);
+						const vb = treeMap.get(b.id);
+						return (va?.order ?? 0) - (vb?.order ?? 0);
+					});
+				}
+				return printJson({
+					label,
+					type,
+					meta,
+					markdown,
+					children
+				});
+			}
+			return markdown || "(empty document)";
+		} catch (error) {
+			return `Error reading document: ${error.message}`;
+		}
+	}
+});
+registerCommand({
+	name: "create",
+	aliases: ["new"],
+	description: "Create a new document in the tree.",
+	usage: "create label=<name> [parent=<docId>] [type=<pageType>] [content=<markdown>] [--format=json]",
+	async run(conn, args) {
+		if (!conn) return "Not connected";
+		const label = args.params["label"] || args.params["name"] || args.positional[0];
+		if (!label) return "Missing required parameter: label=<name>";
+		const treeMap = conn.getTreeMap();
+		const rootDoc = conn.rootDoc;
+		if (!treeMap || !rootDoc) return "Not connected";
+		let parentId = null;
+		if (args.params["parent"]) {
+			parentId = resolveDocument(conn, {
+				id: args.params["parent"],
+				name: args.params["parent"]
+			}, []);
+			if (!parentId) parentId = args.params["parent"];
+		}
+		const normalizedParent = normalizeRootId(parentId || conn.rootDocId, conn);
+		const type = args.params["type"];
+		const id = crypto.randomUUID();
+		const now = Date.now();
+		const meta = {};
+		if (args.params["icon"]) meta["icon"] = args.params["icon"];
+		if (args.params["color"]) meta["color"] = args.params["color"];
+		rootDoc.transact(() => {
+			treeMap.set(id, {
+				label,
+				parentId: normalizedParent,
+				order: now,
+				type,
+				meta: Object.keys(meta).length > 0 ? meta : void 0,
+				createdAt: now,
+				updatedAt: now
+			});
+		});
+		const content = args.params["content"];
+		if (content) try {
+			populateYDocFromMarkdown((await conn.getChildProvider(id)).document.getXmlFragment("default"), content.replace(/\\n/g, "\n").replace(/\\t/g, "	"), label);
+		} catch (error) {
+			return `Created ${id} "${label}" but failed to write content: ${error.message}`;
+		}
+		if (args.params["format"] === "json") return printJson({
+			id,
+			label,
+			parentId: normalizedParent,
+			type
+		});
+		return `Created: ${id.slice(0, 8)}… "${label}"${type ? ` (${type})` : ""}`;
+	}
+});
+registerCommand({
+	name: "rename",
+	description: "Rename a document.",
+	usage: "rename id=<docId> | name=<oldLabel> label=<newLabel>",
+	async run(conn, args) {
+		if (!conn) return "Not connected";
+		const docId = resolveDocument(conn, args.params, args.positional);
+		if (!docId) return "Document not found.";
+		const newLabel = args.params["label"] || args.params["to"];
+		if (!newLabel) return "Missing required parameter: label=<newLabel>";
+		const treeMap = conn.getTreeMap();
+		if (!treeMap) return "Not connected";
+		const raw = treeMap.get(docId);
+		if (!raw) return `Document ${docId} not found.`;
+		const entry = toPlain$1(raw);
+		treeMap.set(docId, {
+			...entry,
+			label: newLabel,
+			updatedAt: Date.now()
+		});
+		return `Renamed to "${newLabel}"`;
+	}
+});
+registerCommand({
+	name: "move",
+	aliases: ["mv"],
+	description: "Move a document to a new parent.",
+	usage: "move id=<docId> | name=<label> to=<parentId> [order=<n>]",
+	async run(conn, args) {
+		if (!conn) return "Not connected";
+		const docId = resolveDocument(conn, args.params, args.positional);
+		if (!docId) return "Document not found.";
+		const newParentId = args.params["to"] || args.params["parent"];
+		if (!newParentId) return "Missing required parameter: to=<parentId>";
+		const treeMap = conn.getTreeMap();
+		if (!treeMap) return "Not connected";
+		const raw = treeMap.get(docId);
+		if (!raw) return `Document ${docId} not found.`;
+		const entry = toPlain$1(raw);
+		const order = args.params["order"] ? parseInt(args.params["order"], 10) : Date.now();
+		treeMap.set(docId, {
+			...entry,
+			parentId: normalizeRootId(newParentId, conn),
+			order,
+			updatedAt: Date.now()
+		});
+		return `Moved ${docId.slice(0, 8)}… to parent ${newParentId.slice(0, 8)}…`;
+	}
+});
+registerCommand({
+	name: "delete",
+	aliases: ["rm", "del"],
+	description: "Soft-delete a document (moves to trash).",
+	usage: "delete id=<docId> | name=<label>",
+	async run(conn, args) {
+		if (!conn) return "Not connected";
+		const docId = resolveDocument(conn, args.params, args.positional);
+		if (!docId) return "Document not found.";
+		const treeMap = conn.getTreeMap();
+		const trashMap = conn.getTrashMap();
+		const rootDoc = conn.rootDoc;
+		if (!treeMap || !trashMap || !rootDoc) return "Not connected";
+		const toDelete = [docId, ...descendantsOf(readEntries(treeMap), docId).map((e) => e.id)];
+		const now = Date.now();
+		rootDoc.transact(() => {
+			for (const nid of toDelete) {
+				const raw = treeMap.get(nid);
+				if (!raw) continue;
+				const entry = toPlain$1(raw);
+				trashMap.set(nid, {
+					label: entry.label || "Untitled",
+					parentId: entry.parentId ?? null,
+					order: entry.order ?? 0,
+					type: entry.type,
+					meta: entry.meta,
+					deletedAt: now
+				});
+				treeMap.delete(nid);
+			}
+		});
+		return `Deleted ${toDelete.length} document(s)`;
+	}
+});
+registerCommand({
+	name: "type",
+	description: "Change the page type view of a document.",
+	usage: "type id=<docId> | name=<label> type=<pageType>",
+	async run(conn, args) {
+		if (!conn) return "Not connected";
+		const docId = resolveDocument(conn, args.params, args.positional);
+		if (!docId) return "Document not found.";
+		const newType = args.params["type"] || args.positional[1];
+		if (!newType) return "Missing required parameter: type=<pageType>";
+		const treeMap = conn.getTreeMap();
+		if (!treeMap) return "Not connected";
+		const raw = treeMap.get(docId);
+		if (!raw) return `Document ${docId} not found.`;
+		const entry = toPlain$1(raw);
+		treeMap.set(docId, {
+			...entry,
+			type: newType,
+			updatedAt: Date.now()
+		});
+		return `Changed type to "${newType}"`;
+	}
+});
+registerCommand({
+	name: "write",
+	description: "Write markdown content to a document (replace or append).",
+	usage: "write id=<docId> | name=<label> content=<markdown> [mode=replace|append]",
+	async run(conn, args) {
+		if (!conn) return "Not connected";
+		const docId = resolveDocument(conn, args.params, args.positional);
+		if (!docId) return "Document not found.";
+		let content = args.params["content"];
+		if (!content) {
+			if (!process.stdin.isTTY) content = await readStdin();
+		}
+		if (!content) return "Missing required parameter: content=<markdown> (or pipe via stdin)";
+		content = content.replace(/\\n/g, "\n").replace(/\\t/g, "	");
+		try {
+			const writeMode = args.params["mode"] ?? "replace";
+			const doc = (await conn.getChildProvider(docId)).document;
+			const fragment = doc.getXmlFragment("default");
+			const { title, meta, body } = parseFrontmatter(content);
+			if (title || Object.keys(meta).length > 0) {
+				const treeMap = conn.getTreeMap();
+				const rootDoc = conn.rootDoc;
+				if (treeMap && rootDoc) {
+					const entry = treeMap.get(docId);
+					if (entry) {
+						const e = toPlain$1(entry);
+						rootDoc.transact(() => {
+							const updates = {
+								...e,
+								updatedAt: Date.now()
+							};
+							if (title) updates.label = title;
+							if (Object.keys(meta).length > 0) updates.meta = {
+								...e.meta ?? {},
+								...meta
+							};
+							treeMap.set(docId, updates);
+						});
+					}
+				}
+			}
+			if (writeMode === "replace") doc.transact(() => {
+				while (fragment.length > 0) fragment.delete(0);
+			});
+			populateYDocFromMarkdown(fragment, body || content, title || "Untitled");
+			return `Document ${docId.slice(0, 8)}… updated (${writeMode} mode)`;
+		} catch (error) {
+			return `Error writing document: ${error.message}`;
+		}
+	}
+});
+registerCommand({
+	name: "duplicate",
+	aliases: ["dup"],
+	description: "Shallow-clone a document.",
+	usage: "duplicate id=<docId> | name=<label>",
+	async run(conn, args) {
+		if (!conn) return "Not connected";
+		const docId = resolveDocument(conn, args.params, args.positional);
+		if (!docId) return "Document not found.";
+		const treeMap = conn.getTreeMap();
+		if (!treeMap) return "Not connected";
+		const raw = treeMap.get(docId);
+		if (!raw) return `Document ${docId} not found.`;
+		const entry = toPlain$1(raw);
+		const newId = crypto.randomUUID();
+		treeMap.set(newId, {
+			...entry,
+			label: (entry.label || "Untitled") + " (copy)",
+			order: Date.now()
+		});
+		return `Duplicated: ${newId.slice(0, 8)}… "${entry.label} (copy)"`;
+	}
+});
+/** Helper to read all of stdin as a string. */
+function readStdin() {
+	return new Promise((resolve, reject) => {
+		let data = "";
+		process.stdin.setEncoding("utf-8");
+		process.stdin.on("data", (chunk) => {
+			data += chunk;
+		});
+		process.stdin.on("end", () => resolve(data));
+		process.stdin.on("error", reject);
+		setTimeout(() => resolve(data), 5e3);
+	});
+}
+
+//#endregion
+//#region packages/cli/src/commands/content.ts
+/**
+* Content commands: append, prepend, wc, export.
+*/
+registerCommand({
+	name: "append",
+	description: "Append content to a document.",
+	usage: "append id=<docId> | name=<label> content=<text> [--inline]",
+	async run(conn, args) {
+		if (!conn) return "Not connected";
+		const docId = resolveDocument(conn, args.params, args.positional);
+		if (!docId) return "Document not found.";
+		const content = args.params["content"];
+		if (!content) return "Missing required parameter: content=<text>";
+		try {
+			populateYDocFromMarkdown((await conn.getChildProvider(docId)).document.getXmlFragment("default"), args.flags.has("inline") ? content.replace(/\\n/g, "\n").replace(/\\t/g, "	") : "\n" + content.replace(/\\n/g, "\n").replace(/\\t/g, "	"), "");
+			return `Appended to ${docId.slice(0, 8)}…`;
+		} catch (error) {
+			return `Error: ${error.message}`;
+		}
+	}
+});
+registerCommand({
+	name: "prepend",
+	description: "Prepend content to a document (after frontmatter).",
+	usage: "prepend id=<docId> | name=<label> content=<text> [--inline]",
+	async run(conn, args) {
+		if (!conn) return "Not connected";
+		const docId = resolveDocument(conn, args.params, args.positional);
+		if (!docId) return "Document not found.";
+		const content = args.params["content"];
+		if (!content) return "Missing required parameter: content=<text>";
+		try {
+			const doc = (await conn.getChildProvider(docId)).document;
+			const fragment = doc.getXmlFragment("default");
+			const { markdown: existing } = yjsToMarkdown(fragment);
+			const text = content.replace(/\\n/g, "\n").replace(/\\t/g, "	");
+			const combined = args.flags.has("inline") ? text + existing : text + "\n" + existing;
+			doc.transact(() => {
+				while (fragment.length > 0) fragment.delete(0);
+			});
+			populateYDocFromMarkdown(fragment, combined, "");
+			return `Prepended to ${docId.slice(0, 8)}…`;
+		} catch (error) {
+			return `Error: ${error.message}`;
+		}
+	}
+});
+registerCommand({
+	name: "wc",
+	aliases: ["wordcount"],
+	description: "Count words and characters in a document.",
+	usage: "wc id=<docId> | name=<label> [--words] [--characters]",
+	async run(conn, args) {
+		if (!conn) return "Not connected";
+		const docId = resolveDocument(conn, args.params, args.positional);
+		if (!docId) return "Document not found.";
+		try {
+			const { markdown } = yjsToMarkdown((await conn.getChildProvider(docId)).document.getXmlFragment("default"));
+			const words = markdown.split(/\s+/).filter(Boolean).length;
+			const chars = markdown.length;
+			if (args.flags.has("words")) return String(words);
+			if (args.flags.has("characters")) return String(chars);
+			return `Words:      ${words}\nCharacters: ${chars}`;
+		} catch (error) {
+			return `Error: ${error.message}`;
+		}
+	}
+});
+registerCommand({
+	name: "export",
+	description: "Export a document as markdown to a local file.",
+	usage: "export id=<docId> | name=<label> output=<filepath>",
+	async run(conn, args) {
+		if (!conn) return "Not connected";
+		const docId = resolveDocument(conn, args.params, args.positional);
+		if (!docId) return "Document not found.";
+		const outputPath = args.params["output"] || args.params["to"] || args.params["path"];
+		if (!outputPath) return "Missing required parameter: output=<filepath>";
+		try {
+			const { title, markdown } = yjsToMarkdown((await conn.getChildProvider(docId)).document.getXmlFragment("default"));
+			const resolvedPath = node_path.resolve(outputPath);
+			node_fs.writeFileSync(resolvedPath, markdown, "utf-8");
+			return `Exported "${title || "document"}" to ${resolvedPath} (${Buffer.byteLength(markdown)} bytes)`;
+		} catch (error) {
+			return `Error: ${error.message}`;
+		}
+	}
+});
+
+//#endregion
+//#region packages/cli/src/commands/meta.ts
+/**
+* Metadata commands: meta, tags.
+*/
+/** Safely read a tree map value. */
+function toPlain(val) {
+	return val instanceof yjs.Map ? val.toJSON() : val;
+}
+registerCommand({
+	name: "meta",
+	aliases: ["metadata"],
+	description: "Get or set document metadata.",
+	usage: "meta id=<docId> | name=<label> [key=value ...] [--format=json]",
+	async run(conn, args) {
+		if (!conn) return "Not connected";
+		const docId = resolveDocument(conn, args.params, args.positional);
+		if (!docId) return "Document not found.";
+		const treeMap = conn.getTreeMap();
+		if (!treeMap) return "Not connected";
+		const raw = treeMap.get(docId);
+		if (!raw) return `Document ${docId} not found.`;
+		const entry = toPlain(raw);
+		const metaKeys = new Set([
+			"icon",
+			"color",
+			"priority",
+			"status",
+			"checked",
+			"rating",
+			"tags",
+			"dateStart",
+			"dateEnd",
+			"datetimeStart",
+			"datetimeEnd",
+			"allDay",
+			"url",
+			"email",
+			"phone",
+			"number",
+			"unit",
+			"subtitle",
+			"note",
+			"taskProgress",
+			"coverUploadId",
+			"geoType",
+			"geoLat",
+			"geoLng",
+			"deskX",
+			"deskY",
+			"deskMode",
+			"spShape",
+			"spColor",
+			"chartType",
+			"kanbanColumnWidth",
+			"galleryColumns",
+			"calendarView",
+			"tableMode"
+		]);
+		const updates = {};
+		let hasUpdates = false;
+		for (const [key, value] of Object.entries(args.params)) if (metaKeys.has(key)) {
+			if (value === "null") updates[key] = null;
+			else if (value === "true") updates[key] = true;
+			else if (value === "false") updates[key] = false;
+			else if ([
+				"priority",
+				"rating",
+				"number",
+				"taskProgress",
+				"geoLat",
+				"geoLng",
+				"deskX",
+				"deskY",
+				"galleryColumns"
+			].includes(key)) updates[key] = parseFloat(value);
+			else if (key === "tags") updates[key] = value.split(",").map((s) => s.trim());
+			else updates[key] = value;
+			hasUpdates = true;
+		}
+		if (hasUpdates) {
+			treeMap.set(docId, {
+				...entry,
+				meta: {
+					...entry.meta ?? {},
+					...updates
+				},
+				updatedAt: Date.now()
+			});
+			return `Metadata updated for ${docId.slice(0, 8)}…`;
+		}
+		const meta = entry.meta ?? {};
+		if (args.params["format"] === "json") return printJson({
+			id: docId,
+			label: entry.label,
+			type: entry.type,
+			meta
+		});
+		if (Object.keys(meta).length === 0) return `Document "${entry.label}" has no metadata.`;
+		return Object.entries(meta).map(([k, v]) => `${k}: ${typeof v === "object" ? JSON.stringify(v) : v}`).join("\n");
+	}
+});
+registerCommand({
+	name: "tags",
+	description: "List tags aggregated from document metadata.",
+	usage: "tags [id=<docId>] [--counts] [--total] [--format=json|tsv]",
+	async run(conn, args) {
+		if (!conn) return "Not connected";
+		const treeMap = conn.getTreeMap();
+		if (!treeMap) return "Not connected";
+		const docId = resolveDocument(conn, args.params, args.positional);
+		if (docId) {
+			const raw = treeMap.get(docId);
+			if (!raw) return `Document ${docId} not found.`;
+			const tags = toPlain(raw).meta?.tags ?? [];
+			if (tags.length === 0) return "No tags.";
+			return tags.join("\n");
+		}
+		const entries = readEntries(treeMap);
+		const tagCounts = /* @__PURE__ */ new Map();
+		for (const entry of entries) {
+			const tags = entry.meta?.tags ?? [];
+			for (const tag of tags) tagCounts.set(tag, (tagCounts.get(tag) ?? 0) + 1);
+		}
+		if (tagCounts.size === 0) return "No tags found.";
+		if (args.flags.has("total")) return String(tagCounts.size);
+		const sorted = [...tagCounts.entries()].sort((a, b) => {
+			if (args.params["sort"] === "count") return b[1] - a[1];
+			return a[0].localeCompare(b[0]);
+		});
+		if (getFormat(args, "text") === "json") return printJson(sorted.map(([tag, count]) => ({
+			tag,
+			count
+		})));
+		if (args.flags.has("counts")) return sorted.map(([tag, count]) => `${tag}\t${count}`).join("\n");
+		return sorted.map(([tag]) => tag).join("\n");
+	}
+});
+
+//#endregion
+//#region packages/cli/src/commands/awareness.ts
+/**
+* Awareness commands: who, status, chat.
+*/
+registerCommand({
+	name: "who",
+	aliases: ["users", "online"],
+	description: "List connected users and their awareness state.",
+	usage: "who [id=<docId>] [--format=json|tsv]",
+	async run(conn, args) {
+		if (!conn) return "Not connected";
+		let awareness;
+		if (args.params["id"]) try {
+			awareness = (await conn.getChildProvider(args.params["id"])).awareness;
+		} catch (error) {
+			return `Error: ${error.message}`;
+		}
+		else {
+			const rootProvider = conn.rootProvider;
+			if (!rootProvider) return "Not connected";
+			awareness = rootProvider.awareness;
+		}
+		const states = awareness.getStates();
+		const selfId = awareness.clientID;
+		const users = [];
+		for (const [clientId, state] of states) {
+			const user = state["user"];
+			if (!user) continue;
+			users.push({
+				name: user.name ?? "Unknown",
+				status: state["status"] ?? "—",
+				docId: state["docId"] ?? "—",
+				isYou: clientId === selfId,
+				isAgent: user.isAgent ?? false
+			});
+		}
+		if (getFormat(args, "text") === "json") return printJson(users);
+		if (users.length === 0) return "No users connected.";
+		return printTable(users.map((u) => [
+			u.name + (u.isYou ? " (you)" : "") + (u.isAgent ? " 🤖" : ""),
+			u.status,
+			u.docId === "—" ? "—" : u.docId.slice(0, 8) + "…"
+		]), [
+			"NAME",
+			"STATUS",
+			"DOCUMENT"
+		]);
+	}
+});
+registerCommand({
+	name: "status",
+	description: "Set your presence status.",
+	usage: "status <text> | status --clear",
+	async run(conn, args) {
+		if (!conn) return "Not connected";
+		const rootProvider = conn.rootProvider;
+		if (!rootProvider) return "Not connected";
+		if (args.flags.has("clear")) {
+			rootProvider.awareness.setLocalStateField("status", null);
+			return "Status cleared.";
+		}
+		const status = args.params["text"] || args.positional[0];
+		if (!status) return "Missing status text. Use: status <text> or status --clear";
+		rootProvider.awareness.setLocalStateField("status", status);
+		return `Status set to "${status}"`;
+	}
+});
+registerCommand({
+	name: "chat",
+	aliases: ["send"],
+	description: "Send a chat message to a channel.",
+	usage: "chat channel=<group:docId> text=<message>",
+	async run(conn, args) {
+		if (!conn) return "Not connected";
+		const rootProvider = conn.rootProvider;
+		if (!rootProvider) return "Not connected";
+		const channel = args.params["channel"];
+		if (!channel) return "Missing required parameter: channel=<group:docId>";
+		const text = args.params["text"] || args.params["content"] || args.positional[0];
+		if (!text) return "Missing required parameter: text=<message>";
+		rootProvider.sendStateless(JSON.stringify({
+			type: "chat:send",
+			channel,
+			content: text,
+			sender_name: conn.displayName
+		}));
+		return `Sent to ${channel}`;
+	}
+});
+
+//#endregion
+//#region packages/cli/src/commands/files.ts
+/**
+* File attachment commands: upload, uploads.
+*/
+registerCommand({
+	name: "uploads",
+	aliases: ["attachments"],
+	description: "List file attachments for a document.",
+	usage: "uploads id=<docId> | name=<label> [--format=json|tsv] [--total]",
+	async run(conn, args) {
+		if (!conn) return "Not connected";
+		const docId = resolveDocument(conn, args.params, args.positional);
+		if (!docId) return "Document not found.";
+		try {
+			const uploads = await conn.client.listUploads(docId);
+			if (args.flags.has("total")) return String(uploads.length);
+			if (getFormat(args, "text") === "json") return printJson(uploads);
+			if (uploads.length === 0) return "No attachments.";
+			return printTable(uploads.map((u) => [
+				u.id.slice(0, 8) + "…",
+				u.filename,
+				u.mime_type ?? "—",
+				u.size ? formatBytes(u.size) : "—"
+			]), [
+				"ID",
+				"FILENAME",
+				"TYPE",
+				"SIZE"
+			]);
+		} catch (error) {
+			return `Error: ${error.message}`;
+		}
+	}
+});
+registerCommand({
+	name: "upload",
+	description: "Upload a local file to a document.",
+	usage: "upload id=<docId> | name=<label> file=<localPath> [filename=<override>]",
+	async run(conn, args) {
+		if (!conn) return "Not connected";
+		const docId = resolveDocument(conn, args.params, args.positional);
+		if (!docId) return "Document not found.";
+		const filePath = args.params["file"] || args.params["path"];
+		if (!filePath) return "Missing required parameter: file=<localPath>";
+		try {
+			const resolvedPath = node_path.resolve(filePath);
+			if (!node_fs.existsSync(resolvedPath)) return `File not found: ${resolvedPath}`;
+			const data = node_fs.readFileSync(resolvedPath);
+			const filename = args.params["filename"] ?? node_path.basename(resolvedPath);
+			const blob = new Blob([data]);
+			const result = await conn.client.upload(docId, blob, filename);
+			return `Uploaded: ${filename} (${formatBytes(data.length)}) → ${result.id}`;
+		} catch (error) {
+			return `Error: ${error.message}`;
+		}
+	}
+});
+registerCommand({
+	name: "download",
+	description: "Download a file attachment from a document.",
+	usage: "download id=<docId> | name=<label> upload=<uploadId> output=<localPath>",
+	async run(conn, args) {
+		if (!conn) return "Not connected";
+		const docId = resolveDocument(conn, args.params, args.positional);
+		if (!docId) return "Document not found.";
+		const uploadId = args.params["upload"] || args.params["uploadId"];
+		if (!uploadId) return "Missing required parameter: upload=<uploadId>";
+		const outputPath = args.params["output"] || args.params["to"];
+		if (!outputPath) return "Missing required parameter: output=<localPath>";
+		try {
+			const blob = await conn.client.getUpload(docId, uploadId);
+			const buffer = Buffer.from(await blob.arrayBuffer());
+			const resolvedPath = node_path.resolve(outputPath);
+			node_fs.writeFileSync(resolvedPath, buffer);
+			return `Downloaded to ${resolvedPath} (${formatBytes(buffer.length)})`;
+		} catch (error) {
+			return `Error: ${error.message}`;
+		}
+	}
+});
+function formatBytes(bytes) {
+	if (bytes < 1024) return `${bytes} B`;
+	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+	return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+//#endregion
+//#region packages/cli/src/commands/permissions.ts
+/**
+* Permission commands: permissions.
+*/
+registerCommand({
+	name: "permissions",
+	aliases: ["perms"],
+	description: "List or set document permissions.",
+	usage: "permissions id=<docId> [user=<userId> role=<role>] [--effective] [--format=json|tsv]",
+	async run(conn, args) {
+		if (!conn) return "Not connected";
+		const docId = resolveDocument(conn, args.params, args.positional);
+		if (!docId) return "Document not found.";
+		const targetUser = args.params["user"] || args.params["user_id"];
+		const targetRole = args.params["role"];
+		if (targetUser && targetRole) try {
+			await conn.client.setPermission(docId, {
+				user_id: targetUser,
+				role: targetRole
+			});
+			return `Set ${targetUser.slice(0, 12)}… → ${targetRole} on ${docId.slice(0, 8)}…`;
+		} catch (error) {
+			return `Error: ${error.message}`;
+		}
+		if (targetUser && args.flags.has("remove")) try {
+			await conn.client.removePermission(docId, { user_id: targetUser });
+			return `Removed permissions for ${targetUser.slice(0, 12)}… on ${docId.slice(0, 8)}…`;
+		} catch (error) {
+			return `Error: ${error.message}`;
+		}
+		try {
+			const format = getFormat(args, "text");
+			if (args.flags.has("effective")) {
+				const result = await conn.client.listEffectivePermissions(docId);
+				if (format === "json") return printJson(result);
+				if (result.permissions.length === 0) return `Default role: ${result.default_role}\nNo explicit permissions.`;
+				const rows = result.permissions.map((p) => [
+					p.display_name || p.username,
+					p.role,
+					p.source,
+					p.inherited_from_doc_id ? p.inherited_from_doc_id.slice(0, 8) + "…" : "—"
+				]);
+				return `Default role: ${result.default_role}\n\n` + printTable(rows, [
+					"USER",
+					"ROLE",
+					"SOURCE",
+					"INHERITED FROM"
+				]);
+			}
+			const perms = await conn.client.listPermissions(docId);
+			if (format === "json") return printJson(perms);
+			if (perms.length === 0) return "No explicit permissions set.";
+			return printTable(perms.map((p) => [
+				p.display_name || p.username,
+				p.role,
+				p.user_id.slice(0, 12) + "…"
+			]), [
+				"USER",
+				"ROLE",
+				"USER ID"
+			]);
+		} catch (error) {
+			return `Error: ${error.message}`;
+		}
+	}
+});
+
+//#endregion
+//#region packages/cli/src/index.ts
+/**
+* Abracadabra CLI — interact with CRDT document workspaces from the terminal.
+*
+* Usage:
+*   abracadabra <command> [key=value ...] [--flags]
+*
+* Environment:
+*   ABRA_URL          Server URL (required)
+*   ABRA_KEY_FILE     Path to Ed25519 key file (~/.abracadabra/cli.key)
+*   ABRA_INVITE_CODE  Invite code for first-run registration
+*   ABRA_NAME         Display name (default: CLI User)
+*   ABRA_COLOR        Presence color (default: hsl(45, 90%, 55%))
+*/
+const NO_CONNECT_COMMANDS = new Set([
+	"help",
+	"h",
+	"?",
+	"version",
+	"v"
+]);
+async function main() {
+	const args = parseArgs(process.argv);
+	const cmd = getCommand(args.command);
+	if (!cmd) {
+		console.error(`Unknown command: "${args.command}"`);
+		console.error("Run \"abracadabra help\" to see all commands.");
+		process.exit(1);
+	}
+	if (NO_CONNECT_COMMANDS.has(args.command)) {
+		let conn = null;
+		const url = process.env["ABRA_URL"];
+		if (url && args.command === "version") try {
+			conn = new CLIConnection({
+				url,
+				name: process.env["ABRA_NAME"],
+				color: process.env["ABRA_COLOR"],
+				inviteCode: process.env["ABRA_INVITE_CODE"],
+				keyFile: process.env["ABRA_KEY_FILE"],
+				quiet: true
+			});
+			await conn.connect();
+		} catch {}
+		try {
+			const output = await cmd.run(conn, args);
+			if (output) console.log(output);
+		} finally {
+			if (conn) await conn.destroy().catch(() => {});
+		}
+		return;
+	}
+	const url = process.env["ABRA_URL"];
+	if (!url) {
+		console.error("Error: ABRA_URL environment variable is required.");
+		console.error("");
+		console.error("Set it to your Abracadabra server URL:");
+		console.error("  export ABRA_URL=https://your-server.example.com");
+		console.error("");
+		console.error("Run \"abracadabra help\" for more info.");
+		process.exit(1);
+	}
+	const conn = new CLIConnection({
+		url,
+		name: process.env["ABRA_NAME"],
+		color: process.env["ABRA_COLOR"],
+		inviteCode: process.env["ABRA_INVITE_CODE"],
+		keyFile: process.env["ABRA_KEY_FILE"],
+		quiet: args.flags.has("quiet") || args.flags.has("q")
+	});
+	try {
+		await conn.connect();
+		const output = await cmd.run(conn, args);
+		if (output) console.log(output);
+	} catch (error) {
+		console.error(`Error: ${error.message}`);
+		if (args.flags.has("verbose")) console.error(error.stack);
+		process.exit(1);
+	} finally {
+		await conn.destroy().catch(() => {});
+	}
+}
+main().catch((err) => {
+	console.error(`Fatal: ${err.message ?? err}`);
+	process.exit(1);
+});
+
+//#endregion
+//# sourceMappingURL=abracadabra-cli.cjs.map