@arcadiasystems/morse-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1962 @@
+#!/usr/bin/env node
+
+// src/cli/errors.ts
+import {
+  ConfigurationError,
+  ContractAbortError,
+  formatUserMessage,
+  NotFoundError,
+  SealError,
+  TransportError,
+  UnauthorizedError,
+  UncertifiedBlobError,
+  ValidationError
+} from "@arcadiasystems/morse-sdk";
+import { CommanderError } from "commander";
+
+// src/format/json.ts
+function replacer(_key, value) {
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (value instanceof Uint8Array) {
+    return `0x${Array.from(value, (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+  }
+  return value;
+}
+function toJson(value) {
+  return JSON.stringify(value, replacer, 2);
+}
+
+// src/cli/exit-codes.ts
+var ExitCode = {
+  Success: 0,
+  Generic: 1,
+  Usage: 2,
+  NotFound: 3,
+  Auth: 4,
+  Network: 5
+};
+
+// src/cli/errors.ts
+class CliError extends Error {
+  exitCode;
+  constructor(message, exitCode = ExitCode.Generic, options) {
+    super(message, options);
+    this.name = "CliError";
+    this.exitCode = exitCode;
+  }
+}
+
+class UsageError extends CliError {
+  constructor(message) {
+    super(message, ExitCode.Usage);
+    this.name = "UsageError";
+  }
+}
+function cancelled() {
+  throw new UsageError("Cancelled. Nothing was changed.");
+}
+
+class KeystoreError extends CliError {
+  constructor(message, options) {
+    super(message, ExitCode.Auth, options);
+    this.name = "KeystoreError";
+  }
+}
+var AUTH_ABORT_REASONS = new Set([
+  "EUnauthorized",
+  "EPublisherCapRevoked",
+  "EPublisherCapWrongHolder"
+]);
+var COMMANDER_SUCCESS_CODES = new Set([
+  "commander.helpDisplayed",
+  "commander.help",
+  "commander.version"
+]);
+function resolveExitCode(err) {
+  if (err instanceof CliError) {
+    return err.exitCode;
+  }
+  if (err instanceof NotFoundError) {
+    return ExitCode.NotFound;
+  }
+  if (err instanceof UnauthorizedError) {
+    return ExitCode.Auth;
+  }
+  if (err instanceof ContractAbortError) {
+    return AUTH_ABORT_REASONS.has(err.reason) ? ExitCode.Auth : ExitCode.Generic;
+  }
+  if (err instanceof TransportError) {
+    return ExitCode.Network;
+  }
+  if (err instanceof SealError) {
+    return err.code === "no-access" ? ExitCode.Auth : ExitCode.Generic;
+  }
+  if (err instanceof ConfigurationError) {
+    return ExitCode.Usage;
+  }
+  if (err instanceof ValidationError) {
+    return ExitCode.Usage;
+  }
+  if (err instanceof UncertifiedBlobError) {
+    return ExitCode.Generic;
+  }
+  return ExitCode.Generic;
+}
+function describe(err) {
+  if (err instanceof CliError) {
+    return { title: "Error", description: err.message };
+  }
+  const formatted = formatUserMessage(err);
+  return { title: formatted.title, description: formatted.description };
+}
+function renderError(err, opts) {
+  const { title, description } = describe(err);
+  const exitCode = resolveExitCode(err);
+  if (opts.json) {
+    process.stderr.write(`${toJson({ error: { title, description, exitCode } })}
+`);
+  } else {
+    process.stderr.write(`Error: ${description}
+`);
+  }
+  if (opts.debug) {
+    writeTrace(err);
+  }
+}
+function writeTrace(err) {
+  let current = err;
+  let prefix = "";
+  while (current instanceof Error && current.stack) {
+    process.stderr.write(`${prefix}${current.stack}
+`);
+    prefix = "Caused by: ";
+    current = current.cause;
+  }
+}
+function handleError(err, opts) {
+  if (err instanceof CommanderError) {
+    return COMMANDER_SUCCESS_CODES.has(err.code) ? ExitCode.Success : ExitCode.Usage;
+  }
+  renderError(err, opts);
+  return resolveExitCode(err);
+}
+
+// src/cli/program.ts
+import { Command } from "commander";
+// package.json
+var package_default = {
+  name: "@arcadiasystems/morse-cli",
+  version: "0.1.0",
+  description: "Command-line interface for the Morse decentralized CMS on Sui.",
+  license: "MIT",
+  type: "module",
+  publishConfig: {
+    access: "public"
+  },
+  keywords: [
+    "sui",
+    "walrus",
+    "seal",
+    "cms",
+    "cli",
+    "decentralized",
+    "blockchain"
+  ],
+  repository: {
+    type: "git",
+    url: "git+https://github.com/arcadiasystems/morse-dcms.git",
+    directory: "morse-cli"
+  },
+  homepage: "https://github.com/arcadiasystems/morse-dcms/tree/main/morse-cli#readme",
+  bugs: {
+    url: "https://github.com/arcadiasystems/morse-dcms/issues"
+  },
+  bin: {
+    morse: "./dist/index.js"
+  },
+  files: [
+    "dist",
+    "docs",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  engines: {
+    node: ">=18",
+    bun: ">=1.2.0"
+  },
+  scripts: {
+    start: "bun src/index.ts",
+    build: "bun build src/index.ts --target node --packages external --outfile dist/index.js",
+    typecheck: "tsc --noEmit",
+    lint: "biome check .",
+    "lint:fix": "biome check --write .",
+    test: "bun test",
+    "test:coverage": "bun test --coverage",
+    prepublishOnly: "tsc --noEmit && biome check . && bun test && bun run build"
+  },
+  dependencies: {
+    "@arcadiasystems/morse-sdk": "^0.1.4",
+    "@mysten/seal": "1.1.3",
+    "@mysten/sui": "2.16.2",
+    "@mysten/walrus": "1.1.6",
+    commander: "^14.0.3"
+  },
+  devDependencies: {
+    "@biomejs/biome": "2.4.7",
+    "@types/bun": "latest",
+    typescript: "^5.6.0"
+  }
+};
+
+// src/cli/program.ts
+function buildProgram() {
+  const program = new Command;
+  program.name("morse").description("Command-line interface for the Morse decentralized CMS on Sui.").version(package_default.version, "-V, --version", "Print the version and exit").option("--network <network>", "Sui network: testnet or localnet [env: MORSE_NETWORK]").option("-p, --profile <name>", "Config profile to use [env: MORSE_PROFILE]").option("--rpc <url>", "Override the Sui RPC URL [env: MORSE_RPC_URL]").option("--json", "Output machine-readable JSON on stdout").option("-q, --quiet", "Suppress progress and informational output").option("-y, --yes", "Assume yes for confirmation prompts").option("--debug", "Print stack traces on error").enablePositionalOptions().showHelpAfterError().exitOverride();
+  return program;
+}
+
+// src/cli/prompts.ts
+import * as readline from "node:readline";
+function isInteractive() {
+  return Boolean(process.stdin.isTTY && process.stderr.isTTY);
+}
+function sigintSignal() {
+  const controller = new AbortController;
+  process.once("SIGINT", () => controller.abort());
+  return controller.signal;
+}
+function promptHidden(label, signal) {
+  return new Promise((resolve, reject) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stderr,
+      terminal: true
+    });
+    const onAbort = () => {
+      rl.close();
+      reject(new UsageError("Prompt aborted."));
+    };
+    bindAbort(signal, onAbort);
+    let muted = false;
+    const mutable = rl;
+    mutable._writeToOutput = (text) => {
+      if (!muted) {
+        process.stderr.write(text);
+      }
+    };
+    rl.question(label, (answer) => {
+      signal?.removeEventListener("abort", onAbort);
+      rl.close();
+      process.stderr.write(`
+`);
+      resolve(answer);
+    });
+    muted = true;
+    rl.on("error", reject);
+  });
+}
+async function confirm(message, options = {}) {
+  if (options.assumeYes) {
+    return true;
+  }
+  if (!isInteractive()) {
+    throw new UsageError(`${message} Refusing to prompt in a non-interactive context; pass --yes to proceed.`);
+  }
+  const answer = await question(`${message} [y/N] `, options.signal);
+  return /^y(es)?$/i.test(answer.trim());
+}
+function question(prompt, signal) {
+  return new Promise((resolve, reject) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stderr
+    });
+    const onAbort = () => {
+      rl.close();
+      reject(new UsageError("Prompt aborted."));
+    };
+    bindAbort(signal, onAbort);
+    rl.question(prompt, (answer) => {
+      signal?.removeEventListener("abort", onAbort);
+      rl.close();
+      resolve(answer);
+    });
+    rl.on("error", reject);
+  });
+}
+function bindAbort(signal, onAbort) {
+  if (signal === undefined) {
+    return;
+  }
+  if (signal.aborted) {
+    onAbort();
+    return;
+  }
+  signal.addEventListener("abort", onAbort, { once: true });
+}
+
+// src/cli/output.ts
+var RESET = "\x1B[0m";
+var YELLOW = "33";
+var DIM = "2";
+
+class Output {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  get isJson() {
+    return this.options.json;
+  }
+  result(human, data) {
+    if (this.options.json) {
+      process.stdout.write(`${toJson(data)}
+`);
+      return;
+    }
+    process.stdout.write(`${human}
+`);
+  }
+  info(message) {
+    if (this.options.quiet || this.options.json) {
+      return;
+    }
+    process.stderr.write(`${this.paint(message, DIM)}
+`);
+  }
+  warn(message) {
+    if (this.options.quiet || this.options.json) {
+      return;
+    }
+    process.stderr.write(`${this.paint(message, YELLOW)}
+`);
+  }
+  paint(text, code) {
+    return this.options.color ? `\x1B[${code}m${text}${RESET}` : text;
+  }
+}
+function resolveColor(json) {
+  if (json) {
+    return false;
+  }
+  if (process.env.NO_COLOR) {
+    return false;
+  }
+  if (process.env.FORCE_COLOR) {
+    return true;
+  }
+  return Boolean(process.stderr.isTTY);
+}
+function createOutput(opts) {
+  const json = Boolean(opts.json);
+  return new Output({
+    json,
+    quiet: Boolean(opts.quiet),
+    color: resolveColor(json)
+  });
+}
+
+// src/cli/runtime.ts
+function globalOptions(command) {
+  return command.optsWithGlobals();
+}
+function outputFor(command) {
+  return createOutput(globalOptions(command));
+}
+
+// src/config/schema.ts
+import { Network } from "@arcadiasystems/morse-sdk";
+var CONFIG_VERSION = 1;
+function emptyConfig() {
+  return { version: CONFIG_VERSION, defaultProfile: "default", profiles: {} };
+}
+var NETWORKS = new Set(Object.values(Network));
+function isNetwork(value) {
+  return typeof value === "string" && NETWORKS.has(value);
+}
+function coerceNetwork(value) {
+  if (value === Network.Mainnet) {
+    throw new UsageError("Morse is not yet deployed on mainnet. Use testnet or localnet.");
+  }
+  if (isNetwork(value)) {
+    return value;
+  }
+  throw new UsageError(`Unknown network "${value}". Use one of: testnet, localnet.`);
+}
+function parseConfig(raw, source) {
+  if (!isRecord(raw)) {
+    throw malformed(source, "expected a JSON object");
+  }
+  const defaultProfile = raw.defaultProfile;
+  if (typeof defaultProfile !== "string") {
+    throw malformed(source, "defaultProfile must be a string");
+  }
+  const profilesRaw = raw.profiles;
+  if (!isRecord(profilesRaw)) {
+    throw malformed(source, "profiles must be an object");
+  }
+  const profiles = {};
+  for (const [name, value] of Object.entries(profilesRaw)) {
+    profiles[name] = parseProfile(name, value, source);
+  }
+  const version = typeof raw.version === "number" ? raw.version : CONFIG_VERSION;
+  return { version, defaultProfile, profiles };
+}
+function parseProfile(name, value, source) {
+  if (!isRecord(value)) {
+    throw malformed(source, `profile "${name}" must be an object`);
+  }
+  if (!isNetwork(value.network)) {
+    throw malformed(source, `profile "${name}" has an invalid network`);
+  }
+  const profile = {
+    network: value.network
+  };
+  if (typeof value.rpc === "string") {
+    profile.rpc = value.rpc;
+  }
+  if (typeof value.account === "string") {
+    profile.account = value.account;
+  }
+  if (typeof value.publication === "string") {
+    profile.publication = value.publication;
+  }
+  if (typeof value.collection === "string") {
+    profile.collection = value.collection;
+  }
+  return profile;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function malformed(source, detail) {
+  return new CliError(`Config file at ${source} is malformed: ${detail}.`, ExitCode.Generic);
+}
+
+// src/config/store.ts
+import { chmod, mkdir, rename } from "node:fs/promises";
+
+// src/cli/io.ts
+import { access, readFile, writeFile } from "node:fs/promises";
+async function fileExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readBytes(path) {
+  return new Uint8Array(await readFile(path));
+}
+async function readJson(path) {
+  return JSON.parse(await readFile(path, "utf8"));
+}
+async function writeFileContents(path, data) {
+  await writeFile(path, data);
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return new Uint8Array(Buffer.concat(chunks));
+}
+
+// src/config/paths.ts
+import { homedir } from "node:os";
+import { join } from "node:path";
+function configDir() {
+  const xdg = process.env.XDG_CONFIG_HOME;
+  const base = xdg && xdg.length > 0 ? xdg : join(homedir(), ".config");
+  return join(base, "morse");
+}
+function configFilePath() {
+  return join(configDir(), "config.json");
+}
+function keystoreDir() {
+  return join(configDir(), "keystores");
+}
+
+// src/config/store.ts
+async function loadConfig() {
+  const path = configFilePath();
+  if (!await fileExists(path)) {
+    return emptyConfig();
+  }
+  let raw;
+  try {
+    raw = await readJson(path);
+  } catch (cause) {
+    throw new CliError(`Config file at ${path} is not valid JSON.`, ExitCode.Generic, { cause });
+  }
+  return parseConfig(raw, path);
+}
+async function saveConfig(config) {
+  const dir = configDir();
+  await mkdir(dir, { recursive: true, mode: 448 });
+  const path = configFilePath();
+  const tmp = `${path}.tmp-${process.pid}-${crypto.randomUUID()}`;
+  await writeFileContents(tmp, `${JSON.stringify(config, null, 2)}
+`);
+  await chmod(tmp, 384);
+  await rename(tmp, path);
+}
+
+// src/config/active.ts
+async function updateActiveProfile(opts, patch, env = process.env) {
+  const config = await loadConfig();
+  const profileName = opts.profile ?? env.MORSE_PROFILE ?? config.defaultProfile;
+  const existing = config.profiles[profileName];
+  const network = coerceNetwork(opts.network ?? env.MORSE_NETWORK ?? existing?.network ?? "testnet");
+  const merged = { ...existing, network, ...patch };
+  const profiles = { ...config.profiles, [profileName]: merged };
+  const defaultProfile = Object.keys(config.profiles).length === 0 ? profileName : config.defaultProfile;
+  await saveConfig({ ...config, profiles, defaultProfile });
+  return profileName;
+}
+
+// src/config/profile.ts
+function resolveSettings(opts, config, env = process.env) {
+  const explicitProfile = opts.profile ?? env.MORSE_PROFILE;
+  const profileName = explicitProfile ?? config.defaultProfile;
+  const profile = config.profiles[profileName];
+  if (explicitProfile !== undefined && profile === undefined) {
+    throw new UsageError(`No profile named "${profileName}". Create it with: morse config add ${profileName} --network testnet`);
+  }
+  const networkValue = opts.network ?? env.MORSE_NETWORK ?? profile?.network ?? "testnet";
+  const network = coerceNetwork(networkValue);
+  const rpcUrl = opts.rpc ?? env.MORSE_RPC_URL ?? profile?.rpc;
+  const account = env.MORSE_ADDRESS ?? profile?.account;
+  const publication = env.MORSE_PUBLICATION ?? profile?.publication;
+  const collection = env.MORSE_COLLECTION ?? profile?.collection;
+  return { profileName, network, rpcUrl, account, publication, collection };
+}
+
+// src/keystore/keystore.ts
+import { chmod as chmod2, mkdir as mkdir2, readdir, rename as rename2, stat } from "node:fs/promises";
+import { join as join2 } from "node:path";
+import { toSuiAddress } from "@arcadiasystems/morse-sdk";
+import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519";
+
+// src/keystore/crypto.ts
+import {
+  createCipheriv,
+  createDecipheriv,
+  randomBytes,
+  scryptSync
+} from "node:crypto";
+var DEFAULT_SCRYPT = { N: 1 << 17, r: 8, p: 1 };
+var KEY_LENGTH = 32;
+var SALT_LENGTH = 16;
+var IV_LENGTH = 12;
+function deriveKey(password, salt, params) {
+  const maxmem = 256 * params.N * params.r;
+  return scryptSync(password, salt, KEY_LENGTH, {
+    N: params.N,
+    r: params.r,
+    p: params.p,
+    maxmem
+  });
+}
+async function encryptSecret(plaintext, password, params = DEFAULT_SCRYPT) {
+  const salt = randomBytes(SALT_LENGTH);
+  const iv = randomBytes(IV_LENGTH);
+  const key = deriveKey(password, salt, params);
+  const cipher = createCipheriv("aes-256-gcm", key, iv);
+  const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+  return {
+    kdfparams: params,
+    salt: salt.toString("base64"),
+    iv: iv.toString("base64"),
+    ciphertext: ciphertext.toString("base64"),
+    authTag: cipher.getAuthTag().toString("base64")
+  };
+}
+async function decryptSecret(payload, password) {
+  const salt = Buffer.from(payload.salt, "base64");
+  const iv = Buffer.from(payload.iv, "base64");
+  const authTag = Buffer.from(payload.authTag, "base64");
+  const ciphertext = Buffer.from(payload.ciphertext, "base64");
+  const key = deriveKey(password, salt, payload.kdfparams);
+  const decipher = createDecipheriv("aes-256-gcm", key, iv);
+  decipher.setAuthTag(authTag);
+  try {
+    const plaintext = Buffer.concat([
+      decipher.update(ciphertext),
+      decipher.final()
+    ]);
+    return new Uint8Array(plaintext);
+  } catch (cause) {
+    throw new KeystoreError("Incorrect password or corrupted keystore.", {
+      cause
+    });
+  }
+}
+
+// src/keystore/keystore.ts
+var KEYSTORE_VERSION = 1;
+function keystorePath(address) {
+  return join2(keystoreDir(), `${toSuiAddress(address)}.json`);
+}
+function keypairFromSecret(secret) {
+  try {
+    return Ed25519Keypair.fromSecretKey(secret);
+  } catch {
+    throw new UsageError("Invalid private key. Expected a Bech32 `suiprivkey1...` secret key.");
+  }
+}
+async function importKey(secret, password) {
+  const keypair = keypairFromSecret(secret);
+  const address = toSuiAddress(keypair.toSuiAddress());
+  const payload = await encryptSecret(new TextEncoder().encode(secret), password);
+  const file = {
+    version: KEYSTORE_VERSION,
+    address,
+    kdf: "scrypt",
+    cipher: "aes-256-gcm",
+    ...payload
+  };
+  await writeKeystore(address, file);
+  return address;
+}
+async function unlockSecret(address, password) {
+  const file = await loadKeystore(address);
+  const bytes = await decryptSecret(file, password);
+  return new TextDecoder().decode(bytes);
+}
+async function listAddresses() {
+  let entries;
+  try {
+    entries = await readdir(keystoreDir());
+  } catch {
+    return [];
+  }
+  return entries.filter((name) => name.endsWith(".json")).map((name) => name.slice(0, -".json".length)).sort();
+}
+async function hasKeystore(address) {
+  return fileExists(keystorePath(address));
+}
+async function loadKeystore(address) {
+  const path = keystorePath(address);
+  if (!await fileExists(path)) {
+    throw new CliError(`No keystore for ${address}. Import it with: morse account import`, ExitCode.NotFound);
+  }
+  await assertSecurePermissions(path);
+  let raw;
+  try {
+    raw = await readJson(path);
+  } catch (cause) {
+    throw new KeystoreError(`Keystore at ${path} is not valid JSON.`, {
+      cause
+    });
+  }
+  return parseKeystore(raw, path);
+}
+async function writeKeystore(address, file) {
+  const dir = keystoreDir();
+  await mkdir2(dir, { recursive: true, mode: 448 });
+  const path = keystorePath(address);
+  const tmp = `${path}.tmp-${process.pid}-${crypto.randomUUID()}`;
+  await writeFileContents(tmp, `${JSON.stringify(file, null, 2)}
+`);
+  await chmod2(tmp, 384);
+  await rename2(tmp, path);
+}
+async function assertSecurePermissions(path) {
+  const mode = (await stat(path)).mode & 511;
+  if ((mode & 63) !== 0) {
+    throw new KeystoreError(`Keystore ${path} is group/world-accessible (mode ${mode.toString(8)}). Run: chmod 600 ${path}`);
+  }
+}
+function parseKeystore(raw, path) {
+  if (typeof raw !== "object" || raw === null) {
+    throw new KeystoreError(`Keystore at ${path} is malformed.`);
+  }
+  const value = raw;
+  const required = ["address", "salt", "iv", "ciphertext", "authTag"];
+  for (const field of required) {
+    if (typeof value[field] !== "string") {
+      throw new KeystoreError(`Keystore at ${path} is missing or has an invalid "${field}".`);
+    }
+  }
+  if (value.version !== KEYSTORE_VERSION) {
+    throw new KeystoreError(`Keystore at ${path} has an unsupported version (expected ${KEYSTORE_VERSION}).`);
+  }
+  if (value.kdf !== "scrypt" || value.cipher !== "aes-256-gcm") {
+    throw new KeystoreError(`Keystore at ${path} uses an unsupported kdf or cipher.`);
+  }
+  const kdfparams = value.kdfparams;
+  if (typeof kdfparams !== "object" || kdfparams === null) {
+    throw new KeystoreError(`Keystore at ${path} is missing kdfparams.`);
+  }
+  assertScryptParams(kdfparams, path);
+  return raw;
+}
+var MAX_SCRYPT_N = 1 << 20;
+var MAX_SCRYPT_RP = 64;
+function assertScryptParams(params, path) {
+  const { N, r, p } = params;
+  const isPowerOfTwo = (n) => (n & n - 1) === 0;
+  if (typeof N !== "number" || !Number.isInteger(N) || N < 1 || N > MAX_SCRYPT_N || !isPowerOfTwo(N)) {
+    throw new KeystoreError(`Keystore at ${path} has an out-of-range kdfparams.N.`);
+  }
+  for (const [name, value] of [
+    ["r", r],
+    ["p", p]
+  ]) {
+    if (typeof value !== "number" || !Number.isInteger(value) || value < 1 || value > MAX_SCRYPT_RP) {
+      throw new KeystoreError(`Keystore at ${path} has an out-of-range kdfparams.${name}.`);
+    }
+  }
+}
+
+// src/keystore/source.ts
+import { toSuiAddress as toSuiAddress2 } from "@arcadiasystems/morse-sdk";
+
+// src/keystore/unlock.ts
+var MIN_PASSWORD_LENGTH = 8;
+async function resolvePassword(purpose, env = process.env, signal) {
+  const fromEnv = env.MORSE_KEYSTORE_PASSWORD;
+  if (fromEnv !== undefined && fromEnv.length > 0) {
+    return fromEnv;
+  }
+  if (!isInteractive()) {
+    throw new KeystoreError("No keystore password available. Set MORSE_KEYSTORE_PASSWORD or run in an interactive terminal.");
+  }
+  if (purpose === "unlock") {
+    return promptHidden("Keystore password (hidden): ", signal);
+  }
+  const first = await promptHidden(`New keystore password (hidden, min ${MIN_PASSWORD_LENGTH} chars): `, signal);
+  if (first.length < MIN_PASSWORD_LENGTH) {
+    throw new UsageError(`Password must be at least ${MIN_PASSWORD_LENGTH} characters.`);
+  }
+  const second = await promptHidden("Confirm password (hidden): ", signal);
+  if (first !== second) {
+    throw new UsageError("Passwords do not match.");
+  }
+  return first;
+}
+
+// src/keystore/source.ts
+async function resolveSigner(account, env = process.env, signal) {
+  const raw = env.MORSE_PRIVATE_KEY;
+  if (raw !== undefined && raw.length > 0) {
+    return toSigner(keypairFromSecret(raw));
+  }
+  if (account === undefined) {
+    throw new UsageError("No account selected. Import one with `morse account import`, select it with `morse account use <address>`, or set MORSE_PRIVATE_KEY.");
+  }
+  const password = await resolvePassword("unlock", env, signal);
+  const secret = await unlockSecret(account, password);
+  return toSigner(keypairFromSecret(secret));
+}
+function toSigner(keypair) {
+  return { keypair, address: toSuiAddress2(keypair.toSuiAddress()) };
+}
+function accountAddress(account, env = process.env) {
+  const raw = env.MORSE_PRIVATE_KEY;
+  if (raw !== undefined && raw.length > 0) {
+    return toSuiAddress2(keypairFromSecret(raw).toSuiAddress());
+  }
+  return account === undefined ? undefined : toSuiAddress2(account);
+}
+
+// src/commands/account.ts
+function registerAccountCommands(program) {
+  const account = program.command("account").description("Import and manage encrypted signing keys");
+  account.command("import").description("Import a private key into an encrypted keystore").action(async (_options, command) => {
+    const opts = globalOptions(command);
+    const output = outputFor(command);
+    const signal = sigintSignal();
+    const secret = await readSecretToImport(process.env, signal);
+    const password = await resolvePassword("create", process.env, signal);
+    const address = await importKey(secret, password);
+    const profileName = await associateAccount(opts, address);
+    output.info(`Imported ${address} into keystore.`);
+    output.result(`Imported account ${address} (profile "${profileName}").`, {
+      address,
+      profile: profileName
+    });
+  });
+  account.command("list").description("List imported accounts").action(async (_options, command) => {
+    const output = outputFor(command);
+    const addresses = await listAddresses();
+    const active = await resolveActiveAccount(globalOptions(command));
+    if (addresses.length === 0) {
+      output.result("No accounts. Import one with: morse account import", {
+        active,
+        accounts: []
+      });
+      return;
+    }
+    const human = addresses.map((address) => `${address === active ? "*" : " "} ${address}`).join(`
+`);
+    output.result(human, { active, accounts: addresses });
+  });
+  account.command("show").description("Print the active account address").action(async (_options, command) => {
+    const output = outputFor(command);
+    const active = await resolveActiveAccount(globalOptions(command));
+    if (active === undefined) {
+      throw new UsageError("No active account. Import one with `morse account import` or set MORSE_ADDRESS.");
+    }
+    output.result(active, { address: active });
+  });
+  account.command("use <address>").description("Set the active account for the current profile").action(async (address, _options, command) => {
+    const opts = globalOptions(command);
+    const output = outputFor(command);
+    if (!await hasKeystore(address)) {
+      throw new UsageError(`No keystore for ${address}. Import it first with: morse account import`);
+    }
+    const profileName = await associateAccount(opts, address);
+    output.result(`Active account for "${profileName}" set to ${address}.`, {
+      address,
+      profile: profileName
+    });
+  });
+  account.command("export <address>").description("Print a decrypted secret key (dangerous)").action(async (address, _options, command) => {
+    const output = outputFor(command);
+    if (output.isJson) {
+      throw new UsageError("account export is not available in --json mode.");
+    }
+    if (!isInteractive()) {
+      throw new UsageError("account export requires an interactive terminal.");
+    }
+    if (globalOptions(command).yes) {
+      throw new UsageError("account export does not accept --yes. Confirm interactively.");
+    }
+    const signal = sigintSignal();
+    const proceed = await confirm(`Reveal the secret key for ${address}? Anyone who sees it controls the account.`, { signal });
+    if (!proceed) {
+      cancelled();
+    }
+    const password = await resolvePassword("unlock", process.env, signal);
+    const secret = await unlockSecret(address, password);
+    process.stderr.write(`Warning: secret key follows. Handle it with care.
+`);
+    process.stdout.write(`${secret}
+`);
+  });
+}
+async function readSecretToImport(env, signal) {
+  const raw = env.MORSE_PRIVATE_KEY;
+  if (raw !== undefined && raw.length > 0) {
+    return raw;
+  }
+  if (!isInteractive()) {
+    throw new UsageError("Cannot read a private key: set MORSE_PRIVATE_KEY or run in an interactive terminal.");
+  }
+  process.stderr.write(`Paste your Sui private key (starts with suiprivkey1...), then press Enter. Input is hidden.
+`);
+  const secret = await promptHidden("Private key (hidden): ", signal);
+  if (secret.length === 0) {
+    throw new UsageError("No private key entered.");
+  }
+  return secret;
+}
+async function associateAccount(opts, address) {
+  return updateActiveProfile(opts, { account: address });
+}
+async function resolveActiveAccount(opts) {
+  return accountAddress(resolveSettings(opts, await loadConfig()).account);
+}
+
+// src/commands/cap.ts
+import {
+  destroyPublisherCap,
+  issuePublisherCap,
+  revokePublisherCap,
+  toPublisherCapId as toPublisherCapId2,
+  toSuiAddress as toSuiAddress3,
+  transferPublisherCap
+} from "@arcadiasystems/morse-sdk";
+
+// src/cli/context.ts
+import {
+  DefaultSealAdapter,
+  DefaultWalrusReadAdapter,
+  DefaultWalrusWriteAdapter,
+  KeypairAdapter,
+  morseConfig,
+  RpcPublicationReader
+} from "@arcadiasystems/morse-sdk";
+import { SuiGrpcClient } from "@mysten/sui/grpc";
+async function buildReadContext(command) {
+  const opts = globalOptions(command);
+  const output = outputFor(command);
+  const settings = resolveSettings(opts, await loadConfig());
+  const config = morseConfig({
+    network: settings.network,
+    ...settings.rpcUrl === undefined ? {} : { rpcUrl: settings.rpcUrl }
+  });
+  const client = new SuiGrpcClient({
+    network: settings.network,
+    baseUrl: config.rpcUrl
+  });
+  const reader = RpcPublicationReader.fromMorseConfig(config, client);
+  return {
+    output,
+    settings,
+    config,
+    client,
+    reader,
+    ownerAddress: accountAddress(settings.account),
+    signal: sigintSignal()
+  };
+}
+async function buildSignedBase(command) {
+  const base = await buildReadContext(command);
+  const signer = await resolveSigner(base.settings.account, process.env, base.signal);
+  return { base, keypair: signer.keypair, address: signer.address };
+}
+async function buildWriteContext(command) {
+  const { base, keypair, address } = await buildSignedBase(command);
+  return {
+    ...base,
+    adapter: new KeypairAdapter(keypair, base.client),
+    address
+  };
+}
+async function buildContentContext(command) {
+  const { base, keypair, address } = await buildSignedBase(command);
+  const network = base.settings.network;
+  if (network === "localnet") {
+    throw new CliError("Walrus content uploads are not available on localnet. Use testnet or mainnet.", ExitCode.Usage);
+  }
+  const adapter = new KeypairAdapter(keypair, base.client);
+  const walrus = DefaultWalrusWriteAdapter.fromConfig({ network, suiClient: base.client }, keypair);
+  return { ...base, adapter, address, walrus };
+}
+async function buildEncryptContext(command) {
+  const ctx = await buildContentContext(command);
+  const seal = DefaultSealAdapter.fromMorseConfig(ctx.config, {}, ctx.client);
+  return { ...ctx, seal };
+}
+async function buildReadContentContext(command) {
+  const base = await buildReadContext(command);
+  const network = base.settings.network;
+  if (network === "localnet") {
+    throw new CliError("Walrus reads are not available on localnet. Use testnet or mainnet.", ExitCode.Usage);
+  }
+  const walrusRead = DefaultWalrusReadAdapter.fromConfig({
+    network,
+    suiClient: base.client
+  });
+  return { ...base, walrusRead };
+}
+async function buildDecryptContext(command) {
+  const { base, keypair, address } = await buildSignedBase(command);
+  const network = base.settings.network;
+  if (network === "localnet") {
+    throw new CliError("Seal decryption is not available on localnet. Use testnet or mainnet.", ExitCode.Usage);
+  }
+  const seal = DefaultSealAdapter.fromMorseConfig(base.config, {}, base.client);
+  const walrusRead = DefaultWalrusReadAdapter.fromConfig({
+    network,
+    suiClient: base.client
+  });
+  return { ...base, keypair, address, seal, walrusRead };
+}
+
+// src/cli/target.ts
+import { toPublicationId } from "@arcadiasystems/morse-sdk";
+var OBJECT_ID = /^0x[0-9a-f]{1,64}$/i;
+var SLUG_PAGE_LIMIT = 50;
+async function resolvePublication(ctx, override) {
+  const value = override ?? ctx.settings.publication;
+  if (value === undefined) {
+    throw new UsageError("No publication selected. Pass --publication <slug|id> or run `morse use <slug|id>`.");
+  }
+  if (OBJECT_ID.test(value)) {
+    return toPublicationId(value.toLowerCase());
+  }
+  return resolveSlug(ctx, value);
+}
+function resolveCollection(ctx, override) {
+  const value = override ?? ctx.settings.collection;
+  if (value === undefined) {
+    throw new UsageError("No collection selected. Pass --collection <name> or run `morse use <slug|id> <collection>`.");
+  }
+  return value;
+}
+async function resolveSlug(ctx, slug) {
+  if (ctx.ownerAddress === undefined) {
+    throw new UsageError(`Cannot resolve the slug "${slug}" without an active account. Pass the publication id, or select an account.`);
+  }
+  ctx.output.info(`Resolving slug "${slug}" among owned publications...`);
+  let cursor;
+  do {
+    const page = await ctx.reader.listPublicationsOwnedBy(ctx.ownerAddress, {
+      limit: SLUG_PAGE_LIMIT,
+      signal: ctx.signal,
+      ...cursor === undefined ? {} : { cursor }
+    });
+    for (const owned of page.results) {
+      const publication = await ctx.reader.getPublication(owned.publicationId, ctx.signal);
+      if (publication.slug === slug) {
+        return publication.id;
+      }
+    }
+    cursor = page.nextCursor ?? undefined;
+  } while (cursor !== undefined);
+  throw new UsageError(`No publication with slug "${slug}" owned by the active account. Pass the publication id instead.`);
+}
+
+// src/format/ids.ts
+var HEAD = 6;
+var TAIL = 4;
+function shortId(id) {
+  if (id.length <= HEAD + TAIL + 3) {
+    return id;
+  }
+  return `${id.slice(0, HEAD)}...${id.slice(-TAIL)}`;
+}
+
+// src/format/render.ts
+function renderEnrichedPublicationList(items) {
+  if (items.length === 0) {
+    return "No publications owned by this address.";
+  }
+  return items.map((p) => `${p.slug}  ${p.publicationId}  ${p.name}`).join(`
+`);
+}
+function renderPublisherCapList(caps) {
+  if (caps.length === 0) {
+    return "No publisher caps held by this address.";
+  }
+  return caps.map((cap) => `${cap.id}  publication ${shortId(cap.publicationId)}  holder ${shortId(cap.holder)}`).join(`
+`);
+}
+function renderCollectionList(collections) {
+  if (collections.length === 0) {
+    return "No collections.";
+  }
+  return collections.map((c) => `${c.name}  ${c.storageMode}  (next entry id ${c.nextEntryId})`).join(`
+`);
+}
+function renderPublication(publication) {
+  const collections = publication.collections.length === 0 ? "(none)" : publication.collections.map((c) => `${c.name} (${c.storageMode})`).join(", ");
+  return [
+    `${publication.name} (${shortId(publication.id)})`,
+    `slug:        ${publication.slug}`,
+    `collections: ${collections}`
+  ].join(`
+`);
+}
+function renderPublicationList(items) {
+  if (items.length === 0) {
+    return "No publications owned by this address.";
+  }
+  return items.map((item) => `${item.publicationId}  (owner cap ${shortId(item.ownerCapId)})`).join(`
+`);
+}
+function renderEntry(entry) {
+  const lines = [
+    `#${entry.id} ${entry.name}`,
+    `publicHead: ${headLabel(entry.publicHead)}  draftHead: ${headLabel(entry.draftHead)}`,
+    `revisions:  ${entry.revisions.length}`
+  ];
+  for (const revision of entry.revisions) {
+    lines.push(`  ${renderRevisionLine(revision)}`);
+  }
+  return lines.join(`
+`);
+}
+function renderEntryList(entries) {
+  if (entries.length === 0) {
+    return "No entries in this collection.";
+  }
+  return entries.map((entry) => `#${entry.id} ${entry.name} (${entry.revisions.length} revisions)`).join(`
+`);
+}
+function headLabel(value) {
+  return value === null ? "none" : String(value);
+}
+function renderRevisionLine(revision) {
+  const ref = revision.blobRef.kind === "blob" ? `blob ${shortId(revision.blobRef.blobObjectId)}` : "quilt patch";
+  const encrypted = revision.encrypted ? " encrypted" : "";
+  return `[${revision.id}] ${revision.contentType} (${ref}) by ${shortId(revision.author)}${encrypted}`;
+}
+
+// src/commands/options.ts
+function publicationOption(command) {
+  return command.option("-P, --publication <slug|id>", "Publication slug or id (default: the active publication)");
+}
+function collectionOption(command) {
+  return command.option("-C, --collection <name>", "Collection name (default: the active collection)");
+}
+function publisherCapOption(command) {
+  return command.option("--publisher-cap <id>", "PublisherCap ID (auto-resolved if omitted)");
+}
+function ownerCapOption(command) {
+  return command.option("--owner-cap <id>", "OwnerCap ID (auto-resolved if omitted)");
+}
+function contentOptions(command) {
+  return command.option("-f, --file <path>", "File to upload (or - for stdin)").option("--stdin", "Read content from stdin").option("--content-type <type>", "MIME content type (inferred from --file if omitted)").option("--epochs <n>", "Walrus storage epochs", "3");
+}
+
+// src/commands/resolve.ts
+import {
+  toOwnerCapId,
+  toPublisherCapId
+} from "@arcadiasystems/morse-sdk";
+var PAGE_LIMIT = 50;
+async function resolveOwnerCap(reader, address, publicationId, override, signal) {
+  if (override !== undefined) {
+    return toOwnerCapId(override);
+  }
+  let cursor;
+  do {
+    const page = await reader.listPublicationsOwnedBy(address, {
+      limit: PAGE_LIMIT,
+      signal,
+      ...cursor === undefined ? {} : { cursor }
+    });
+    const match = page.results.find((o) => o.publicationId === publicationId);
+    if (match !== undefined) {
+      return match.ownerCapId;
+    }
+    cursor = page.nextCursor ?? undefined;
+  } while (cursor !== undefined);
+  throw new CliError(`No OwnerCap for ${publicationId} held by ${address}. Pass --owner-cap, or check that the active account owns it.`, ExitCode.NotFound);
+}
+async function resolvePublisherCap(reader, address, publicationId, override, signal) {
+  if (override !== undefined) {
+    return toPublisherCapId(override);
+  }
+  let cursor;
+  do {
+    const page = await reader.listPublisherCapsOwnedBy(address, {
+      limit: PAGE_LIMIT,
+      signal,
+      ...cursor === undefined ? {} : { cursor }
+    });
+    const match = page.results.find((c) => c.publicationId === publicationId);
+    if (match !== undefined) {
+      return match.id;
+    }
+    cursor = page.nextCursor ?? undefined;
+  } while (cursor !== undefined);
+  throw new CliError(`No PublisherCap for ${publicationId} held by ${address}. Pass --publisher-cap, or check that the active account holds one.`, ExitCode.NotFound);
+}
+
+// src/commands/shared.ts
+import { StorageMode } from "@arcadiasystems/morse-sdk";
+var STORAGE_MODES = new Set(Object.values(StorageMode));
+function coerceStorageMode(value) {
+  if (STORAGE_MODES.has(value)) {
+    return value;
+  }
+  throw new UsageError(`--mode must be one of: ${Object.values(StorageMode).join(", ")}, got "${value}".`);
+}
+function parsePositiveInt(value, name) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    throw new UsageError(`${name} must be a positive integer, got "${value}".`);
+  }
+  return parsed;
+}
+function parseLimit(value) {
+  return parsePositiveInt(value, "--limit");
+}
+function parseId(value, name) {
+  const id = Number(value);
+  if (!Number.isInteger(id) || id < 0) {
+    throw new UsageError(`${name} must be a non-negative integer, got "${value}".`);
+  }
+  return id;
+}
+
+// src/commands/cap.ts
+function registerCapCommands(program) {
+  const cap = program.command("cap").description("Manage PublisherCaps (write-access capabilities)");
+  cap.command("list [address]").description("List publisher caps held by an address (default: the active account)").option("--limit <n>", "Maximum results per page").option("--cursor <cursor>", "Continue from a previous page cursor").action(async (address, options, command) => {
+    const ctx = await buildReadContext(command);
+    const holder = address === undefined ? ctx.ownerAddress : toSuiAddress3(address);
+    if (holder === undefined) {
+      throw new UsageError("No address given and no active account. Pass an address or import an account.");
+    }
+    const page = await ctx.reader.listPublisherCapsOwnedBy(holder, {
+      signal: ctx.signal,
+      ...options.limit === undefined ? {} : { limit: parseLimit(options.limit) },
+      ...options.cursor === undefined ? {} : { cursor: options.cursor }
+    });
+    if (page.nextCursor !== null) {
+      ctx.output.info(`More results: pass --cursor "${page.nextCursor}"`);
+    }
+    ctx.output.result(renderPublisherCapList(page.results), {
+      results: page.results,
+      nextCursor: page.nextCursor
+    });
+  });
+  const issue = cap.command("issue <holder>").description("Issue a PublisherCap bound to an address");
+  publicationOption(ownerCapOption(issue)).action(async (holder, options, command) => {
+    const ctx = await buildWriteContext(command);
+    const id = await resolvePublication(ctx, options.publication);
+    const holderAddress = toSuiAddress3(holder);
+    ctx.output.info("Resolving OwnerCap...");
+    const ownerCapId = await resolveOwnerCap(ctx.reader, ctx.address, id, options.ownerCap, ctx.signal);
+    const result = await issuePublisherCap(ctx.adapter, ctx.config, {
+      publicationId: id,
+      ownerCapId,
+      holder: holderAddress,
+      signal: ctx.signal
+    });
+    ctx.output.result(`Issued PublisherCap ${result.publisherCapId} to ${holderAddress}. (tx: ${result.digest})`, result);
+  });
+  const revoke = cap.command("revoke <publisherCapId>").description("Revoke a PublisherCap so it can no longer write");
+  publicationOption(ownerCapOption(revoke)).action(async (publisherCapId, options, command) => {
+    const ctx = await buildWriteContext(command);
+    const id = await resolvePublication(ctx, options.publication);
+    const capId = toPublisherCapId2(publisherCapId);
+    const proceed = await confirm(`Revoke PublisherCap ${capId}? It can no longer be used to write.`, { assumeYes: Boolean(globalOptions(command).yes), signal: ctx.signal });
+    if (!proceed) {
+      cancelled();
+    }
+    ctx.output.info("Resolving OwnerCap...");
+    const ownerCapId = await resolveOwnerCap(ctx.reader, ctx.address, id, options.ownerCap, ctx.signal);
+    const result = await revokePublisherCap(ctx.adapter, ctx.config, {
+      publicationId: id,
+      ownerCapId,
+      publisherCapId: capId,
+      signal: ctx.signal
+    });
+    ctx.output.result(`Revoked PublisherCap ${capId}. (tx: ${result.digest})`, result);
+  });
+  const destroy = cap.command("destroy <publisherCapId>").description("Destroy a PublisherCap held by the active account");
+  publicationOption(destroy).action(async (publisherCapId, options, command) => {
+    const ctx = await buildWriteContext(command);
+    const id = await resolvePublication(ctx, options.publication);
+    const capId = toPublisherCapId2(publisherCapId);
+    const proceed = await confirm(`Destroy PublisherCap ${capId}? This is permanent.`, { assumeYes: Boolean(globalOptions(command).yes), signal: ctx.signal });
+    if (!proceed) {
+      cancelled();
+    }
+    const result = await destroyPublisherCap(ctx.adapter, ctx.config, {
+      publicationId: id,
+      publisherCapId: capId,
+      signal: ctx.signal
+    });
+    ctx.output.result(`Destroyed PublisherCap ${capId}. (tx: ${result.digest})`, result);
+  });
+  cap.command("transfer <publisherCapId> <recipient>").description("Transfer a PublisherCap object to another address").action(async (publisherCapId, recipient, _options, command) => {
+    const ctx = await buildWriteContext(command);
+    const capId = toPublisherCapId2(publisherCapId);
+    const to = toSuiAddress3(recipient);
+    const proceed = await confirm(`Transfer PublisherCap ${capId} to ${to}?`, {
+      assumeYes: Boolean(globalOptions(command).yes),
+      signal: ctx.signal
+    });
+    if (!proceed) {
+      cancelled();
+    }
+    const result = await transferPublisherCap(ctx.adapter, ctx.config, {
+      publisherCapId: capId,
+      recipient: to,
+      signal: ctx.signal
+    });
+    ctx.output.result(`Transferred PublisherCap ${capId} to ${to}. (tx: ${result.digest})`, result);
+  });
+}
+
+// src/commands/collection.ts
+import { createCollection, deleteCollection } from "@arcadiasystems/morse-sdk";
+function registerCollectionCommands(program) {
+  const collection = program.command("collection").description("Manage collections within a publication");
+  const list = collection.command("list").description("List the collections in a publication");
+  publicationOption(list).action(async (options, command) => {
+    const ctx = await buildReadContext(command);
+    const id = await resolvePublication(ctx, options.publication);
+    const publication = await ctx.reader.getPublication(id, ctx.signal);
+    ctx.output.result(renderCollectionList(publication.collections), {
+      publication: id,
+      collections: publication.collections
+    });
+  });
+  const create = collection.command("create <name>").description("Create a collection and select it as the active collection").option("--mode <mode>", "Storage mode: blob or quilt", "blob");
+  publicationOption(publisherCapOption(create)).action(async (name, options, command) => {
+    const ctx = await buildWriteContext(command);
+    const id = await resolvePublication(ctx, options.publication);
+    const storageMode = coerceStorageMode(options.mode);
+    const publisherCapId = await resolvePublisherCap(ctx.reader, ctx.address, id, options.publisherCap, ctx.signal);
+    ctx.output.info(`Creating collection "${name}" (${storageMode})...`);
+    const result = await createCollection(ctx.adapter, ctx.config, {
+      publicationId: id,
+      publisherCapId,
+      name,
+      storageMode,
+      signal: ctx.signal
+    });
+    await updateActiveProfile(globalOptions(command), { collection: name });
+    ctx.output.result(`Created collection "${name}". Selected as the active collection. (tx: ${result.digest})`, result);
+  });
+  const remove = collection.command("delete <name>").description("Delete an empty collection");
+  publicationOption(publisherCapOption(remove)).action(async (name, options, command) => {
+    const ctx = await buildWriteContext(command);
+    const id = await resolvePublication(ctx, options.publication);
+    const proceed = await confirm(`Delete collection "${name}" from ${shortId(id)}? It must be empty.`, { assumeYes: Boolean(globalOptions(command).yes), signal: ctx.signal });
+    if (!proceed) {
+      cancelled();
+    }
+    const publisherCapId = await resolvePublisherCap(ctx.reader, ctx.address, id, options.publisherCap, ctx.signal);
+    const result = await deleteCollection(ctx.adapter, ctx.config, {
+      publicationId: id,
+      publisherCapId,
+      name,
+      signal: ctx.signal
+    });
+    if (ctx.settings.collection === name) {
+      await updateActiveProfile(globalOptions(command), {
+        collection: undefined
+      });
+    }
+    ctx.output.result(`Deleted collection "${name}". (tx: ${result.digest})`, result);
+  });
+}
+
+// src/commands/config.ts
+function registerConfigCommands(program) {
+  const config = program.command("config").description("Manage profiles and CLI configuration");
+  config.command("path").description("Print the config file path").action((_options, command) => {
+    const path = configFilePath();
+    outputFor(command).result(path, { path });
+  });
+  config.command("list").description("List profiles and show the default").action(async (_options, command) => {
+    const cfg = await loadConfig();
+    outputFor(command).result(renderProfiles(cfg), {
+      defaultProfile: cfg.defaultProfile,
+      profiles: cfg.profiles
+    });
+  });
+  config.command("add <name>").description("Create or update a profile").requiredOption("--network <network>", "Sui network: testnet or localnet").option("--rpc <url>", "RPC URL override for this profile").action(async (name, options, command) => {
+    const network = coerceNetwork(options.network);
+    const cfg = await loadConfig();
+    const profiles = {
+      ...cfg.profiles,
+      [name]: {
+        network,
+        ...options.rpc === undefined ? {} : { rpc: options.rpc }
+      }
+    };
+    const defaultProfile = Object.keys(cfg.profiles).length === 0 ? name : cfg.defaultProfile;
+    await saveConfig({ ...cfg, profiles, defaultProfile });
+    outputFor(command).result(`Saved profile "${name}" (${network}).`, {
+      profile: name,
+      network,
+      rpc: options.rpc,
+      default: defaultProfile === name
+    });
+  });
+  config.command("use <name>").description("Set the default profile").action(async (name, _options, command) => {
+    const cfg = await loadConfig();
+    requireProfile(cfg, name);
+    await saveConfig({ ...cfg, defaultProfile: name });
+    outputFor(command).result(`Default profile set to "${name}".`, {
+      defaultProfile: name
+    });
+  });
+  config.command("remove <name>").description("Delete a profile").action(async (name, _options, command) => {
+    const cfg = await loadConfig();
+    requireProfile(cfg, name);
+    const { [name]: _removed, ...rest } = cfg.profiles;
+    const defaultProfile = cfg.defaultProfile === name ? Object.keys(rest)[0] ?? "default" : cfg.defaultProfile;
+    await saveConfig({ ...cfg, profiles: rest, defaultProfile });
+    outputFor(command).result(`Removed profile "${name}".`, {
+      removed: name,
+      defaultProfile,
+      profiles: Object.keys(rest)
+    });
+  });
+}
+function requireProfile(config, name) {
+  if (!(name in config.profiles)) {
+    throw new UsageError(`No profile named "${name}". Create it with: morse config add ${name} --network testnet`);
+  }
+}
+function renderProfiles(config) {
+  const names = Object.keys(config.profiles);
+  if (names.length === 0) {
+    return "No profiles configured. Add one with: morse config add <name> --network testnet";
+  }
+  return names.map((name) => {
+    const profile = config.profiles[name];
+    if (profile === undefined) {
+      return name;
+    }
+    const marker = name === config.defaultProfile ? "*" : " ";
+    const parts = [profile.network];
+    if (profile.rpc !== undefined) {
+      parts.push(profile.rpc);
+    }
+    if (profile.account !== undefined) {
+      parts.push(profile.account);
+    }
+    return `${marker} ${name}  ${parts.join("  ")}`;
+  }).join(`
+`);
+}
+
+// src/commands/entry.ts
+import {
+  addEntryFromBytes,
+  deleteEntry
+} from "@arcadiasystems/morse-sdk";
+
+// src/cli/input.ts
+import { extname } from "node:path";
+var EXTENSION_TYPES = {
+  ".txt": "text/plain",
+  ".md": "text/markdown",
+  ".html": "text/html",
+  ".json": "application/json",
+  ".csv": "text/csv",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".pdf": "application/pdf"
+};
+var DEFAULT_CONTENT_TYPE = "application/octet-stream";
+async function readContentBytes(options) {
+  const bytes = await readRaw(options);
+  if (bytes.length === 0) {
+    throw new UsageError("Content is empty; nothing to upload.");
+  }
+  return bytes;
+}
+async function readRaw(options) {
+  if (options.stdin || options.file === "-") {
+    return readStdin();
+  }
+  if (options.file === undefined) {
+    throw new UsageError("Provide content with --file <path> or --stdin.");
+  }
+  if (!await fileExists(options.file)) {
+    throw new UsageError(`File not found: ${options.file}`);
+  }
+  return readBytes(options.file);
+}
+function resolveContentType(explicit, file) {
+  if (explicit !== undefined) {
+    return explicit;
+  }
+  if (file !== undefined && file !== "-") {
+    const type = EXTENSION_TYPES[extname(file).toLowerCase()];
+    if (type !== undefined) {
+      return type;
+    }
+  }
+  return DEFAULT_CONTENT_TYPE;
+}
+
+// src/commands/encrypted.ts
+import {
+  addEncryptedEntryFromBytes,
+  buildPublisherSealId
+} from "@arcadiasystems/morse-sdk";
+import { SessionKey } from "@mysten/seal";
+var SESSION_KEY_TTL_MIN = 10;
+var SEAL_NONCE_BYTES = 16;
+function registerEncryptedEntryCommands(entry) {
+  const add = entry.command("add-encrypted <name>").description("Encrypt a file or stdin with Seal and add it as a new entry");
+  collectionOption(publicationOption(publisherCapOption(contentOptions(add)))).action(async (name, options, command) => {
+    const ctx = await buildEncryptContext(command);
+    const id = await resolvePublication(ctx, options.publication);
+    const collection = resolveCollection(ctx, options.collection);
+    const epochs = parsePositiveInt(options.epochs, "--epochs");
+    const plaintext = await readContentBytes(options);
+    const contentType = resolveContentType(options.contentType, options.stdin ? undefined : options.file);
+    const publisherCapId = await resolvePublisherCap(ctx.reader, ctx.address, id, options.publisherCap, ctx.signal);
+    const sealId = buildPublisherSealId(id, crypto.getRandomValues(new Uint8Array(SEAL_NONCE_BYTES)));
+    ctx.output.info(`Encrypting and uploading ${plaintext.length} bytes...`);
+    const result = await addEncryptedEntryFromBytes(ctx.adapter, ctx.config, {
+      walrus: ctx.walrus,
+      seal: ctx.seal,
+      publicationId: id,
+      publisherCapId,
+      collectionName: collection,
+      name,
+      plaintext,
+      contentType,
+      sealId,
+      upload: { epochs, deletable: true },
+      signal: ctx.signal
+    });
+    ctx.output.result(`Added encrypted entry #${result.entryId} "${name}". (tx: ${result.digest})`, { ...result, sealId });
+  });
+  const decrypt = entry.command("decrypt <entryId> [revisionIndex]").description("Decrypt an encrypted revision by zero-based index (default: latest); signs a SessionKey with the active account").option("--out <path>", "Write plaintext to a file instead of stdout");
+  collectionOption(publicationOption(publisherCapOption(decrypt))).action(async (entryId, revisionId, options, command) => {
+    const ctx = await buildDecryptContext(command);
+    if (ctx.output.isJson && options.out === undefined) {
+      throw new UsageError("Decrypting to stdout is not supported in --json mode; pass --out <path>.");
+    }
+    const id = await resolvePublication(ctx, options.publication);
+    const collection = resolveCollection(ctx, options.collection);
+    const numericEntryId = parseId(entryId, "entryId");
+    const entryData = await ctx.reader.getEntry(id, collection, numericEntryId, ctx.signal);
+    if (revisionId === undefined && entryData.revisions.length === 0) {
+      throw new UsageError(`Entry #${numericEntryId} has no revisions.`);
+    }
+    const revisionIndex = revisionId === undefined ? entryData.revisions.length - 1 : parseId(revisionId, "revision");
+    const revision = entryData.revisions[revisionIndex];
+    if (revision === undefined) {
+      throw new UsageError(`Entry #${numericEntryId} has no revision at index ${revisionIndex}.`);
+    }
+    if (!revision.encrypted || revision.sealId === null) {
+      throw new UsageError(`Revision #${revisionIndex} of entry #${numericEntryId} is not encrypted.`);
+    }
+    const publisherCapId = await resolvePublisherCap(ctx.reader, ctx.address, id, options.publisherCap, ctx.signal);
+    ctx.output.info("Fetching ciphertext from Walrus...");
+    const ciphertext = await ctx.walrusRead.readBlobRef(revision.blobRef, {
+      signal: ctx.signal
+    });
+    ctx.output.info("Signing a SessionKey with the active account...");
+    const sessionKey = await SessionKey.create({
+      address: ctx.address,
+      packageId: ctx.config.originalPackageId ?? ctx.config.packageId,
+      ttlMin: SESSION_KEY_TTL_MIN,
+      signer: ctx.keypair,
+      suiClient: ctx.client
+    });
+    const plaintext = await ctx.seal.decrypt(ciphertext, {
+      sessionKey,
+      sealId: revision.sealId,
+      publisherCapId
+    });
+    if (options.out !== undefined) {
+      await writeFileContents(options.out, plaintext);
+      ctx.output.result(`Wrote ${plaintext.length} bytes to ${options.out}.`, {
+        entryId: numericEntryId,
+        revisionId: revisionIndex,
+        bytes: plaintext.length,
+        contentType: revision.contentType,
+        out: options.out
+      });
+      return;
+    }
+    process.stdout.write(plaintext);
+  });
+}
+
+// src/commands/entry.ts
+function registerEntryCommands(program) {
+  const entry = program.command("entry").description("Read, add, and delete entries in a collection");
+  const get = entry.command("get <entryId>").description("Fetch a single entry");
+  collectionOption(publicationOption(get)).action(async (entryId, options, command) => {
+    const ctx = await buildReadContext(command);
+    const id = await resolvePublication(ctx, options.publication);
+    const collection = resolveCollection(ctx, options.collection);
+    const result = await ctx.reader.getEntry(id, collection, parseId(entryId, "entryId"), ctx.signal);
+    ctx.output.result(renderEntry(result), result);
+  });
+  const list = entry.command("list").description("List entries in a collection").option("--limit <n>", "Maximum results per page").option("--cursor <cursor>", "Continue from a previous page cursor");
+  collectionOption(publicationOption(list)).action(async (options, command) => {
+    const ctx = await buildReadContext(command);
+    const id = await resolvePublication(ctx, options.publication);
+    const collection = resolveCollection(ctx, options.collection);
+    const page = await ctx.reader.listEntries(id, collection, {
+      signal: ctx.signal,
+      ...options.limit === undefined ? {} : { limit: parseLimit(options.limit) },
+      ...options.cursor === undefined ? {} : { cursor: options.cursor }
+    });
+    if (page.nextCursor !== null) {
+      ctx.output.info(`More results: pass --cursor "${page.nextCursor}"`);
+    }
+    ctx.output.result(renderEntryList(page.results), {
+      results: page.results,
+      nextCursor: page.nextCursor
+    });
+  });
+  const scan = entry.command("scan").description("List every entry in a collection (auto-paginated)");
+  collectionOption(publicationOption(scan)).action(async (options, command) => {
+    const ctx = await buildReadContext(command);
+    const id = await resolvePublication(ctx, options.publication);
+    const collection = resolveCollection(ctx, options.collection);
+    const entries = [];
+    for await (const item of ctx.reader.scanEntries(id, collection, {
+      signal: ctx.signal
+    })) {
+      entries.push(item);
+    }
+    ctx.output.result(renderEntryList(entries), { results: entries });
+  });
+  const add = entry.command("add <name>").description("Upload content from a file or stdin and add it as a new entry");
+  collectionOption(publicationOption(publisherCapOption(contentOptions(add)))).action(async (name, options, command) => {
+    const ctx = await buildContentContext(command);
+    const id = await resolvePublication(ctx, options.publication);
+    const collection = resolveCollection(ctx, options.collection);
+    const epochs = parsePositiveInt(options.epochs, "--epochs");
+    const bytes = await readContentBytes(options);
+    const contentType = resolveContentType(options.contentType, options.stdin ? undefined : options.file);
+    const publisherCapId = await resolvePublisherCap(ctx.reader, ctx.address, id, options.publisherCap, ctx.signal);
+    ctx.output.info(`Uploading ${bytes.length} bytes to Walrus...`);
+    const result = await addEntryFromBytes(ctx.adapter, ctx.config, {
+      walrus: ctx.walrus,
+      publicationId: id,
+      publisherCapId,
+      collectionName: collection,
+      name,
+      bytes,
+      contentType,
+      upload: { epochs, deletable: true },
+      signal: ctx.signal
+    });
+    const aggregator = ctx.config.walrusEndpoints.aggregator;
+    const viewUrl = aggregator.length > 0 ? `${aggregator}/v1/blobs/${result.blobId}` : undefined;
+    const human = viewUrl === undefined ? `Added entry #${result.entryId} "${name}". (tx: ${result.digest})` : `Added entry #${result.entryId} "${name}". (tx: ${result.digest})
+  view: ${viewUrl}`;
+    ctx.output.result(human, { ...result, viewUrl: viewUrl ?? null });
+  });
+  const remove = entry.command("delete <entryId>").description("Delete an entry and its revisions");
+  collectionOption(publicationOption(publisherCapOption(remove))).action(async (entryId, options, command) => {
+    const ctx = await buildWriteContext(command);
+    const id = await resolvePublication(ctx, options.publication);
+    const collection = resolveCollection(ctx, options.collection);
+    const numericEntryId = parseId(entryId, "entryId");
+    const proceed = await confirm(`Delete entry #${numericEntryId} from ${shortId(id)}/${collection}? This cannot be undone.`, { assumeYes: Boolean(globalOptions(command).yes), signal: ctx.signal });
+    if (!proceed) {
+      cancelled();
+    }
+    const publisherCapId = await resolvePublisherCap(ctx.reader, ctx.address, id, options.publisherCap, ctx.signal);
+    const result = await deleteEntry(ctx.adapter, ctx.config, {
+      publicationId: id,
+      publisherCapId,
+      collectionName: collection,
+      entryId: numericEntryId,
+      signal: ctx.signal
+    });
+    ctx.output.result(`Deleted entry #${numericEntryId}. (tx: ${result.digest})`, result);
+  });
+  const read = entry.command("read <entryId> [revisionIndex]").description("Fetch a public entry's content to stdout or a file").option("--out <path>", "Write content to a file instead of stdout");
+  collectionOption(publicationOption(read)).action(async (entryId, revisionId, options, command) => {
+    const ctx = await buildReadContentContext(command);
+    if (ctx.output.isJson && options.out === undefined) {
+      throw new UsageError("Reading content to stdout is not supported in --json mode; pass --out <path>.");
+    }
+    const id = await resolvePublication(ctx, options.publication);
+    const collection = resolveCollection(ctx, options.collection);
+    const numericEntryId = parseId(entryId, "entryId");
+    const entryData = await ctx.reader.getEntry(id, collection, numericEntryId, ctx.signal);
+    if (revisionId === undefined && entryData.revisions.length === 0) {
+      throw new UsageError(`Entry #${numericEntryId} has no revisions.`);
+    }
+    const revisionIndex = revisionId === undefined ? entryData.revisions.length - 1 : parseId(revisionId, "revision");
+    const revision = entryData.revisions[revisionIndex];
+    if (revision === undefined) {
+      throw new UsageError(`Entry #${numericEntryId} has no revision at index ${revisionIndex}.`);
+    }
+    if (revision.encrypted) {
+      throw new UsageError(`Revision #${revisionIndex} of entry #${numericEntryId} is encrypted; use \`morse entry decrypt\`.`);
+    }
+    ctx.output.info("Fetching content from Walrus...");
+    const bytes = await ctx.walrusRead.readBlobRef(revision.blobRef, {
+      signal: ctx.signal
+    });
+    if (options.out !== undefined) {
+      await writeFileContents(options.out, bytes);
+      ctx.output.result(`Wrote ${bytes.length} bytes to ${options.out}.`, {
+        entryId: numericEntryId,
+        revisionId: revisionIndex,
+        bytes: bytes.length,
+        contentType: revision.contentType,
+        out: options.out
+      });
+      return;
+    }
+    process.stdout.write(bytes);
+  });
+  registerEncryptedEntryCommands(entry);
+}
+
+// src/commands/publication.ts
+import {
+  createPublication,
+  deletePublication,
+  toSuiAddress as toSuiAddress4,
+  transferOwnership
+} from "@arcadiasystems/morse-sdk";
+function registerPublicationCommands(program) {
+  const publication = program.command("publication").alias("pub").description("Work with publications");
+  publication.command("get [publication]").description("Fetch a publication (slug or id; default: the active publication)").action(async (target, _options, command) => {
+    const ctx = await buildReadContext(command);
+    const id = await resolvePublication(ctx, target);
+    const result = await ctx.reader.getPublication(id, ctx.signal);
+    ctx.output.result(renderPublication(result), result);
+  });
+  publication.command("list [address]").description("List publications owned by an address (default: the active account)").option("--limit <n>", "Maximum results per page").option("--cursor <cursor>", "Continue from a previous page cursor").option("--ids-only", "Skip slug/name resolution (one RPC, no per-publication reads)").action(async (address, options, command) => {
+    const ctx = await buildReadContext(command);
+    const owner = address === undefined ? ctx.ownerAddress : toSuiAddress4(address);
+    if (owner === undefined) {
+      throw new UsageError("No address given and no active account. Pass an address or import an account.");
+    }
+    const page = await ctx.reader.listPublicationsOwnedBy(owner, {
+      signal: ctx.signal,
+      ...options.limit === undefined ? {} : { limit: parseLimit(options.limit) },
+      ...options.cursor === undefined ? {} : { cursor: options.cursor }
+    });
+    if (page.nextCursor !== null) {
+      ctx.output.info(`More results: pass --cursor "${page.nextCursor}"`);
+    }
+    if (options.idsOnly) {
+      ctx.output.result(renderPublicationList(page.results), {
+        results: page.results,
+        nextCursor: page.nextCursor
+      });
+      return;
+    }
+    const enriched = [];
+    for (const owned of page.results) {
+      const pub = await ctx.reader.getPublication(owned.publicationId, ctx.signal);
+      enriched.push({
+        slug: pub.slug,
+        name: pub.name,
+        publicationId: owned.publicationId,
+        ownerCapId: owned.ownerCapId
+      });
+    }
+    ctx.output.result(renderEnrichedPublicationList(enriched), {
+      results: enriched,
+      nextCursor: page.nextCursor
+    });
+  });
+  publication.command("create").description("Create a publication and select it as the active publication").requiredOption("-n, --name <name>", "Publication name").requiredOption("-s, --slug <slug>", "URL slug: lowercase alphanumeric and hyphens, 1-64 chars").action(async (options, command) => {
+    const ctx = await buildWriteContext(command);
+    ctx.output.info(`Creating "${options.name}"...`);
+    const result = await createPublication(ctx.adapter, ctx.config, {
+      name: options.name,
+      slug: options.slug,
+      signal: ctx.signal
+    });
+    await updateActiveProfile(globalOptions(command), {
+      publication: result.publicationId,
+      collection: undefined
+    });
+    const human = [
+      `Created "${options.name}" (${result.publicationId})`,
+      `  ownerCap:     ${result.ownerCapId}`,
+      `  publisherCap: ${result.publisherCapId}`,
+      `  tx:           ${result.digest}`,
+      "Selected as the active publication."
+    ].join(`
+`);
+    ctx.output.result(human, result);
+  });
+  publication.command("delete [publication]").description("Delete an empty publication (default: the active publication)").option("--owner-cap <id>", "OwnerCap ID (auto-resolved if omitted)").action(async (target, options, command) => {
+    const ctx = await buildWriteContext(command);
+    const id = await resolvePublication(ctx, target);
+    const proceed = await confirm(`Delete publication ${shortId(id)}? This cannot be undone.`, {
+      assumeYes: Boolean(globalOptions(command).yes),
+      signal: ctx.signal
+    });
+    if (!proceed) {
+      cancelled();
+    }
+    ctx.output.info("Resolving OwnerCap...");
+    const ownerCapId = await resolveOwnerCap(ctx.reader, ctx.address, id, options.ownerCap, ctx.signal);
+    ctx.output.info("Deleting...");
+    const result = await deletePublication(ctx.reader, ctx.adapter, ctx.config, {
+      publicationId: id,
+      ownerCapId,
+      signal: ctx.signal
+    });
+    if (ctx.settings.publication === id) {
+      await updateActiveProfile(globalOptions(command), {
+        publication: undefined,
+        collection: undefined
+      });
+    }
+    ctx.output.result(`Deleted ${id}. (tx: ${result.digest})`, result);
+  });
+  const transfer = publication.command("transfer-ownership <recipient>").description("Transfer a publication's OwnerCap to another address");
+  publicationOption(ownerCapOption(transfer)).action(async (recipient, options, command) => {
+    const ctx = await buildWriteContext(command);
+    const id = await resolvePublication(ctx, options.publication);
+    const to = toSuiAddress4(recipient);
+    const proceed = await confirm(`Transfer ownership of ${shortId(id)} to ${to}? You will lose owner control.`, { assumeYes: Boolean(globalOptions(command).yes), signal: ctx.signal });
+    if (!proceed) {
+      cancelled();
+    }
+    ctx.output.info("Resolving OwnerCap...");
+    const ownerCapId = await resolveOwnerCap(ctx.reader, ctx.address, id, options.ownerCap, ctx.signal);
+    const result = await transferOwnership(ctx.adapter, ctx.config, {
+      ownerCapId,
+      recipient: to,
+      signal: ctx.signal
+    });
+    ctx.output.result(`Transferred ownership of ${id} to ${to}. (tx: ${result.digest})`, result);
+  });
+}
+
+// src/commands/revision.ts
+import {
+  appendDraftRevision,
+  publishDirect,
+  publishFromDraft
+} from "@arcadiasystems/morse-sdk";
+function revisionOptions(command) {
+  return collectionOption(publicationOption(publisherCapOption(contentOptions(command))));
+}
+async function resolveTarget(command, options) {
+  const ctx = await buildContentContext(command);
+  const publicationId = await resolvePublication(ctx, options.publication);
+  const collection = resolveCollection(ctx, options.collection);
+  return { ctx, publicationId, collection };
+}
+async function prepareContent(target, options) {
+  const { ctx, publicationId } = target;
+  const epochs = parsePositiveInt(options.epochs, "--epochs");
+  const bytes = await readContentBytes(options);
+  const contentType = resolveContentType(options.contentType, options.stdin ? undefined : options.file);
+  const publisherCapId = await resolvePublisherCap(ctx.reader, ctx.address, publicationId, options.publisherCap, ctx.signal);
+  ctx.output.info(`Uploading ${bytes.length} bytes to Walrus...`);
+  const upload = await ctx.walrus.uploadBlob(bytes, {
+    epochs,
+    deletable: true
+  });
+  ctx.output.info(`Blob uploaded (${upload.blobObjectId}). Submitting transaction...`);
+  return { blobObjectId: upload.blobObjectId, contentType, publisherCapId };
+}
+function registerRevisionCommands(program) {
+  const revision = program.command("revision").description("Append or publish revisions on an entry");
+  revisionOptions(revision.command("publish-direct <entryId>").description("Upload content and append it as a public revision")).action(async (entryId, options, command) => {
+    const target = await resolveTarget(command, options);
+    const numericEntryId = parseId(entryId, "entryId");
+    const prepared = await prepareContent(target, options);
+    const result = await publishDirect(target.ctx.adapter, target.ctx.config, {
+      publicationId: target.publicationId,
+      publisherCapId: prepared.publisherCapId,
+      collectionName: target.collection,
+      entryId: numericEntryId,
+      blobObjectId: prepared.blobObjectId,
+      contentType: prepared.contentType,
+      signal: target.ctx.signal
+    });
+    target.ctx.output.result(`Published revision #${result.revisionId} on entry #${numericEntryId}. (tx: ${result.digest})`, result);
+  });
+  revisionOptions(revision.command("append-draft <entryId>").description("Upload content and append it as a draft revision")).action(async (entryId, options, command) => {
+    const target = await resolveTarget(command, options);
+    const numericEntryId = parseId(entryId, "entryId");
+    const prepared = await prepareContent(target, options);
+    const result = await appendDraftRevision(target.ctx.adapter, target.ctx.config, {
+      publicationId: target.publicationId,
+      publisherCapId: prepared.publisherCapId,
+      collectionName: target.collection,
+      entryId: numericEntryId,
+      blobObjectId: prepared.blobObjectId,
+      contentType: prepared.contentType,
+      signal: target.ctx.signal
+    });
+    target.ctx.output.result(`Appended draft revision #${result.revisionId} on entry #${numericEntryId}. (tx: ${result.digest})`, result);
+  });
+  revisionOptions(revision.command("publish-from-draft <entryId> <draftRevisionId>").description("Upload content and publish it as a new revision, referencing a draft")).action(async (entryId, draftRevisionId, options, command) => {
+    const target = await resolveTarget(command, options);
+    const numericEntryId = parseId(entryId, "entryId");
+    const draftId = parseId(draftRevisionId, "draftRevisionId");
+    const prepared = await prepareContent(target, options);
+    const result = await publishFromDraft(target.ctx.adapter, target.ctx.config, {
+      publicationId: target.publicationId,
+      publisherCapId: prepared.publisherCapId,
+      collectionName: target.collection,
+      entryId: numericEntryId,
+      draftRevisionId: draftId,
+      blobObjectId: prepared.blobObjectId,
+      contentType: prepared.contentType,
+      signal: target.ctx.signal
+    });
+    target.ctx.output.result(`Published revision #${result.revisionId} from draft #${draftId} on entry #${numericEntryId}. (tx: ${result.digest})`, result);
+  });
+}
+
+// src/commands/use.ts
+function registerContextCommands(program) {
+  program.command("use [publication] [collection]").description("Set the active publication (slug or id) and optional collection. Omitting the collection clears any active collection.").option("--clear", "Clear the active publication and collection").action(async (publication, collection, options, command) => {
+    const opts = globalOptions(command);
+    const output = outputFor(command);
+    if (options.clear) {
+      const profile2 = await updateActiveProfile(opts, {
+        publication: undefined,
+        collection: undefined
+      });
+      output.result(`Cleared the active publication and collection (profile "${profile2}").`, { profile: profile2, publication: null, collection: null });
+      return;
+    }
+    if (publication === undefined) {
+      throw new UsageError("Provide a publication (slug or id), or pass --clear.");
+    }
+    const ctx = await buildReadContext(command);
+    const publicationId = await resolvePublication(ctx, publication);
+    let collectionName;
+    if (collection !== undefined) {
+      const pub = await ctx.reader.getPublication(publicationId, ctx.signal);
+      if (!pub.collections.some((c) => c.name === collection)) {
+        throw new UsageError(`Publication ${publicationId} has no collection "${collection}".`);
+      }
+      collectionName = collection;
+    }
+    const profile = await updateActiveProfile(opts, {
+      publication: publicationId,
+      collection: collectionName
+    });
+    const human = collectionName === undefined ? `Active publication set to ${publicationId} (profile "${profile}").` : `Active publication set to ${publicationId}, collection "${collectionName}" (profile "${profile}").`;
+    output.result(human, {
+      profile,
+      publication: publicationId,
+      collection: collectionName ?? null
+    });
+  });
+  program.command("status").description("Show the active profile, network, account, publication, and collection").action(async (_options, command) => {
+    const output = outputFor(command);
+    const settings = resolveSettings(globalOptions(command), await loadConfig());
+    const account = accountAddress(settings.account);
+    const human = [
+      `profile:     ${settings.profileName}`,
+      `network:     ${settings.network}`,
+      `account:     ${account ?? "(none)"}`,
+      `publication: ${settings.publication ?? "(none)"}`,
+      `collection:  ${settings.collection ?? "(none)"}`
+    ].join(`
+`);
+    output.result(human, {
+      profile: settings.profileName,
+      network: settings.network,
+      account: account ?? null,
+      publication: settings.publication ?? null,
+      collection: settings.collection ?? null
+    });
+  });
+}
+
+// src/commands/index.ts
+function registerCommands(program) {
+  registerConfigCommands(program);
+  registerAccountCommands(program);
+  registerContextCommands(program);
+  registerPublicationCommands(program);
+  registerCollectionCommands(program);
+  registerEntryCommands(program);
+  registerRevisionCommands(program);
+  registerCapCommands(program);
+}
+
+// src/index.ts
+var program = buildProgram();
+registerCommands(program);
+if (process.argv.length <= 2) {
+  program.outputHelp();
+  process.exitCode = 0;
+} else {
+  try {
+    await program.parseAsync();
+  } catch (err) {
+    const opts = program.opts();
+    process.exitCode = handleError(err, {
+      json: Boolean(opts.json),
+      debug: Boolean(opts.debug)
+    });
+  }
+}