@orbitmem/cli 0.1.0

package/README.md

@@ -0,0 +1,152 @@
+# @orbitmem/cli
+
+CLI for OrbitMem — manage vaults, discover data, and interact with on-chain registries.
+
+## Install
+
+```bash
+npm install -g @orbitmem/cli
+```
+
+## Quick Start
+
+```bash
+# Initialize (generate keys, create config)
+orbitmem init --name my-wallet --network base-sepolia
+
+# Store data
+orbitmem vault store /notes/hello "Hello, world!"
+
+# Read data
+orbitmem vault get /notes/hello
+
+# List keys
+orbitmem vault ls
+
+# Check status
+orbitmem status
+```
+
+## Commands
+
+### `init`
+
+Generate keys and create `~/.orbitmem/config.json`.
+
+```bash
+orbitmem init --name <wallet> --network <chain> [--force]
+```
+
+### `status`
+
+Show identity, config, and vault info.
+
+```bash
+orbitmem status [--relay <url>] [--json]
+```
+
+### `vault store <path> <value>`
+
+Store data in vault.
+
+```bash
+# Private (default, AES encrypted)
+orbitmem vault store /secret "sensitive data"
+
+# Public (plaintext)
+orbitmem vault store /public/bio "Hello" --public
+
+# Shared with Lit access conditions
+orbitmem vault store /shared/data "gated info" \
+  --shared --engine lit --allow-address 0x1234...
+
+# Require minimum reputation score
+orbitmem vault store /gated/data "quality data" \
+  --shared --engine lit --min-score 100
+```
+
+### `vault get <path>`
+
+Read data from vault.
+
+```bash
+orbitmem vault get /notes/hello [--relay <url>] [--json]
+```
+
+### `vault ls [prefix]`
+
+List vault keys.
+
+```bash
+orbitmem vault ls
+orbitmem vault ls /notes
+```
+
+### `vault update-access <path>`
+
+Re-encrypt with new Lit access conditions.
+
+```bash
+orbitmem vault update-access /shared/data --allow-address 0xNewAddr...
+```
+
+### `vault price`
+
+Manage per-read pricing (micropayments).
+
+```bash
+orbitmem vault price set /data 5.50          # Set price in USDC
+orbitmem vault price set /data 2.00 --currency EUR
+orbitmem vault price get /data               # Show price
+orbitmem vault price ls                      # List priced paths
+orbitmem vault price rm /data                # Remove pricing
+```
+
+### `register`
+
+Register data on-chain for discovery (ERC-8004).
+
+```bash
+orbitmem register /my/data \
+  --name "My Dataset" \
+  --description "A useful dataset" \
+  --schema json \
+  --tags data,public
+```
+
+### `discover`
+
+Search on-chain data registries.
+
+```bash
+orbitmem discover json --tags public --min-quality 80
+```
+
+### `snapshot`
+
+Archive vault to Filecoin/IPFS via Storacha.
+
+```bash
+orbitmem snapshot --label "backup-2026-03"
+```
+
+### `dev`
+
+Start local relay server for development.
+
+```bash
+orbitmem dev [--port 3000]
+```
+
+## Global Options
+
+| Flag | Description |
+|------|-------------|
+| `--relay <url>` | Override relay URL |
+| `--chain <name>` | Override blockchain |
+| `--json` | Output as JSON |
+| `--help` | Show help |
+
+## License
+
+MIT

package/dist/index.js

@@ -0,0 +1,820 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { getNetwork } from "@orbitmem/sdk/contracts";
+function defaultConfig(network) {
+  const net = getNetwork(network);
+  return {
+    network: network ?? "base-sepolia",
+    relay: net.relayUrl,
+    chain: net.chain,
+    registryAddress: net.dataRegistry,
+    reputationAddress: net.feedbackRegistry
+  };
+}
+function getConfigDir() {
+  return process.env.ORBITMEM_HOME ?? join(homedir(), ".orbitmem");
+}
+function ensureDir() {
+  const dir = getConfigDir();
+  if (!existsSync(dir))
+    mkdirSync(dir, { recursive: true });
+}
+function loadConfig() {
+  const configPath = join(getConfigDir(), "config.json");
+  const defaults = defaultConfig();
+  if (!existsSync(configPath))
+    return { walletName: "", ...defaults };
+  const raw = JSON.parse(readFileSync(configPath, "utf-8"));
+  const base = raw.network ? defaultConfig(raw.network) : defaults;
+  return { walletName: "", ...base, ...raw };
+}
+function toCaip2(network) {
+  const map = {
+    "base-sepolia": "eip155:84532",
+    base: "eip155:8453"
+  };
+  return map[network] ?? "eip155:84532";
+}
+function saveConfig(config) {
+  ensureDir();
+  const configPath = join(getConfigDir(), "config.json");
+  const existing = loadConfig();
+  const merged = { ...existing, ...config };
+  writeFileSync(configPath, `${JSON.stringify(merged, null, 2)}
+`);
+}
+var init_config = () => {};
+
+// src/utils/output.ts
+function output(data, json) {
+  if (json) {
+    process.stdout.write(`${JSON.stringify(data, null, 2)}
+`);
+  } else if (typeof data === "string") {
+    process.stdout.write(`${data}
+`);
+  } else if (Array.isArray(data)) {
+    printTable(data);
+  } else if (typeof data === "object" && data !== null) {
+    for (const [key, value] of Object.entries(data)) {
+      process.stdout.write(`${key}: ${value}
+`);
+    }
+  }
+}
+function printTable(rows) {
+  if (rows.length === 0) {
+    process.stdout.write(`(empty)
+`);
+    return;
+  }
+  const keys = Object.keys(rows[0]);
+  const widths = keys.map((k) => Math.max(k.length, ...rows.map((r) => String(r[k] ?? "").length)));
+  const header = keys.map((k, i) => k.padEnd(widths[i])).join("  ");
+  const sep = widths.map((w) => "─".repeat(w)).join("──");
+  process.stdout.write(`${header}
+${sep}
+`);
+  for (const row of rows) {
+    const line = keys.map((k, i) => String(row[k] ?? "").padEnd(widths[i])).join("  ");
+    process.stdout.write(`${line}
+`);
+  }
+}
+function error(msg) {
+  process.stderr.write(`error: ${msg}
+`);
+  process.exit(1);
+}
+
+// src/commands/init.ts
+var exports_init = {};
+__export(exports_init, {
+  init: () => init
+});
+import { existsSync as existsSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+import { createWallet } from "@open-wallet-standard/core";
+import { createOwsAdapter } from "@orbitmem/sdk/identity";
+async function init(_args, flags) {
+  const configDir = getConfigDir();
+  const configPath = join2(configDir, "config.json");
+  if (existsSync2(configPath) && flags.force === undefined) {
+    const existing = loadConfig();
+    if (existing.walletName) {
+      process.stderr.write(`Already initialized at ${configDir}. Use --force to reinitialize.
+`);
+      process.exit(1);
+    }
+  }
+  const walletName = flags.name ?? "orbitmem";
+  createWallet(walletName);
+  const network = flags.network ?? "base-sepolia";
+  saveConfig({ walletName, network });
+  const config = loadConfig();
+  const caip2 = toCaip2(network);
+  const adapter = createOwsAdapter(walletName, caip2);
+  const address = await adapter.getAddress();
+  const info = {
+    wallet: walletName,
+    address,
+    configDir,
+    network: config.network,
+    relay: config.relay,
+    chain: config.chain,
+    dataRegistry: config.registryAddress,
+    feedbackRegistry: config.reputationAddress
+  };
+  if (flags.json !== undefined) {
+    output(info, true);
+  } else {
+    process.stdout.write(`
+OrbitMem initialized!
+
+`);
+    process.stdout.write(`  Wallet:            ${info.wallet}
+`);
+    process.stdout.write(`  Config:            ${info.configDir}
+`);
+    process.stdout.write(`  Network:           ${info.network}
+`);
+    process.stdout.write(`  Relay:             ${info.relay}
+`);
+    process.stdout.write(`  Chain:             ${info.chain}
+`);
+    process.stdout.write(`  DataRegistry:      ${info.dataRegistry}
+`);
+    process.stdout.write(`  FeedbackRegistry:  ${info.feedbackRegistry}
+
+`);
+  }
+}
+var init_init = __esm(() => {
+  init_config();
+});
+
+// src/commands/status.ts
+var exports_status = {};
+__export(exports_status, {
+  status: () => status
+});
+import { createOwsAdapter as createOwsAdapter2 } from "@orbitmem/sdk/identity";
+async function status(_args, flags) {
+  const config = loadConfig();
+  if (!config.walletName) {
+    error("Not initialized. Run `orbitmem init` first.");
+  }
+  const caip2 = toCaip2(config.network);
+  const adapter = createOwsAdapter2(config.walletName, caip2);
+  const address = await adapter.getAddress();
+  const info = {
+    wallet: config.walletName,
+    address,
+    configDir: getConfigDir(),
+    relay: flags.relay ?? config.relay,
+    chain: flags.chain ?? config.chain,
+    registryAddress: config.registryAddress ?? "(not set)",
+    reputationAddress: config.reputationAddress ?? "(not set)"
+  };
+  output(info, flags.json !== undefined);
+}
+var init_status = __esm(() => {
+  init_config();
+});
+
+// src/utils/client.ts
+import { createOrbitMem, getNetwork as getNetwork2 } from "@orbitmem/sdk";
+import { createOwsAdapter as createOwsAdapter3 } from "@orbitmem/sdk/identity";
+import { createPublicClient, createWalletClient, http } from "viem";
+import { base, baseSepolia } from "viem/chains";
+async function createClient(config, opts) {
+  const network = getNetwork2(config.network);
+  const chain = CHAINS[config.network] ?? baseSepolia;
+  const transport = http(network.rpcUrl);
+  const adapter = createOwsAdapter3(config.walletName, `eip155:${chain.id}`);
+  const viemAccount = await adapter.toViemAccount();
+  const publicClient = createPublicClient({ chain, transport });
+  const walletClient = createWalletClient({ chain, transport, account: viemAccount });
+  const encryption = {
+    defaultEngine: "aes",
+    aes: { kdf: "hkdf-sha256" }
+  };
+  if (opts?.litNetwork) {
+    encryption.lit = { network: opts.litNetwork };
+  }
+  const client = await createOrbitMem({
+    network: config.network,
+    identity: { owsWallet: config.walletName },
+    vault: { dbName: "orbitmem-cli" },
+    encryption,
+    persistence: {
+      relayUrl: config.relay
+    },
+    discovery: {
+      dataRegistry: network.dataRegistry,
+      reputationRegistry: network.feedbackRegistry,
+      registryChain: network.chain,
+      publicClient,
+      walletClient
+    }
+  });
+  await client.connect({ method: "evm" });
+  return client;
+}
+var CHAINS;
+var init_client = __esm(() => {
+  CHAINS = {
+    "base-sepolia": baseSepolia,
+    base
+  };
+});
+
+// src/commands/vault.ts
+var exports_vault = {};
+__export(exports_vault, {
+  vault: () => vault
+});
+async function vault(args, flags) {
+  const sub = args[0];
+  switch (sub) {
+    case "store":
+      return vaultStore(args.slice(1), flags);
+    case "get":
+      return vaultGet(args.slice(1), flags);
+    case "ls":
+      return vaultLs(args.slice(1), flags);
+    case "update-access":
+      return vaultUpdateAccess(args.slice(1), flags);
+    case "price":
+      return vaultPrice(args.slice(1), flags);
+    default:
+      error(`Unknown vault command: ${sub ?? "(none)"}. Use: store, get, ls, update-access, price`);
+  }
+}
+async function vaultStore(args, flags) {
+  const [path, ...valueParts] = args;
+  const value = valueParts.join(" ");
+  if (!path || !value)
+    error("Usage: orbitmem vault store <path> <value>");
+  const config = loadConfig();
+  if (flags.relay)
+    config.relay = flags.relay;
+  const engine = flags.engine ?? "aes";
+  const litNetwork = flags["lit-network"] ?? "cayenne";
+  const useLit = engine === "lit";
+  const client = await createClient(config, useLit ? { litNetwork } : undefined);
+  try {
+    let visibility;
+    if (flags.public !== undefined) {
+      visibility = "public";
+    } else if (flags.shared !== undefined || useLit) {
+      visibility = "shared";
+    } else {
+      visibility = "private";
+    }
+    const putOpts = { visibility };
+    if (useLit) {
+      putOpts.engine = "lit";
+      const accessConditions = [];
+      if (flags["allow-address"]) {
+        const chain = flags["access-chain"] ?? config.chain ?? "base-sepolia";
+        const condition = {
+          conditionType: "evmBasic",
+          contractAddress: "",
+          standardContractType: "",
+          chain,
+          method: "",
+          parameters: [":userAddress"],
+          returnValueTest: { comparator: "=", value: flags["allow-address"] }
+        };
+        accessConditions.push(condition);
+      }
+      if (flags["min-score"]) {
+        const chain = flags["access-chain"] ?? config.chain ?? "base-sepolia";
+        const condition = {
+          conditionType: "evmContract",
+          contractAddress: config.reputationAddress,
+          standardContractType: "",
+          chain,
+          method: "getScore",
+          parameters: [":userAddress"],
+          returnValueTest: { comparator: ">=", value: flags["min-score"] }
+        };
+        accessConditions.push(condition);
+      }
+      if (accessConditions.length === 0) {
+        error("Lit encryption requires --allow-address <addr> or --min-score <n>");
+      }
+      putOpts.accessConditions = accessConditions;
+    }
+    const entry = await client.vault.put(path, value, putOpts);
+    const result = {
+      path,
+      visibility,
+      engine,
+      encrypted: entry.encrypted,
+      timestamp: entry.timestamp
+    };
+    if (flags.json !== undefined) {
+      output(result, true);
+    } else {
+      const engineLabel = useLit ? " [lit]" : "";
+      process.stdout.write(`Stored "${path}" (${visibility}${engineLabel})
+`);
+    }
+  } finally {
+    await client.destroy();
+  }
+}
+async function vaultUpdateAccess(args, flags) {
+  const [path] = args;
+  if (!path)
+    error("Usage: orbitmem vault update-access <path> --allow-address <addr> | --min-score <n>");
+  const config = loadConfig();
+  if (flags.relay)
+    config.relay = flags.relay;
+  const litNetwork = flags["lit-network"] ?? "cayenne";
+  const client = await createClient(config, { litNetwork });
+  try {
+    const accessConditions = [];
+    const chain = flags["access-chain"] ?? config.chain ?? "base-sepolia";
+    if (flags["allow-address"]) {
+      const condition = {
+        conditionType: "evmBasic",
+        contractAddress: "",
+        standardContractType: "",
+        chain,
+        method: "",
+        parameters: [":userAddress"],
+        returnValueTest: { comparator: "=", value: flags["allow-address"] }
+      };
+      accessConditions.push(condition);
+    }
+    if (flags["min-score"]) {
+      const condition = {
+        conditionType: "evmContract",
+        contractAddress: config.reputationAddress,
+        standardContractType: "",
+        chain,
+        method: "getScore",
+        parameters: [":userAddress"],
+        returnValueTest: { comparator: ">=", value: flags["min-score"] }
+      };
+      accessConditions.push(condition);
+    }
+    if (accessConditions.length === 0) {
+      error("update-access requires --allow-address <addr> or --min-score <n>");
+    }
+    const vault2 = client.vault;
+    const entry = await vault2.updateAccess(path, accessConditions, { chain });
+    if (flags.json !== undefined) {
+      output({ path, updated: true, timestamp: entry.timestamp }, true);
+    } else {
+      process.stdout.write(`Updated access for "${path}"
+`);
+    }
+  } finally {
+    await client.destroy();
+  }
+}
+async function vaultGet(args, flags) {
+  const [path] = args;
+  if (!path)
+    error("Usage: orbitmem vault get <path>");
+  const config = loadConfig();
+  if (flags.relay)
+    config.relay = flags.relay;
+  const client = await createClient(config);
+  try {
+    const entry = await client.vault.get(path);
+    if (!entry)
+      error(`Not found: ${path}`);
+    output(flags.json !== undefined ? entry : entry.value, flags.json !== undefined);
+  } finally {
+    await client.destroy();
+  }
+}
+async function vaultLs(args, flags) {
+  const [prefix] = args;
+  const config = loadConfig();
+  if (flags.relay)
+    config.relay = flags.relay;
+  const client = await createClient(config);
+  try {
+    const keys = await client.vault.keys(prefix);
+    if (flags.json !== undefined) {
+      output(keys, true);
+    } else if (keys.length === 0) {
+      process.stdout.write(`(no entries)
+`);
+    } else {
+      for (const key of keys) {
+        process.stdout.write(`${key}
+`);
+      }
+    }
+  } finally {
+    await client.destroy();
+  }
+}
+async function vaultPrice(args, flags) {
+  const action = args[0];
+  switch (action) {
+    case "set":
+      return vaultPriceSet(args.slice(1), flags);
+    case "get":
+      return vaultPriceGet(args.slice(1), flags);
+    case "ls":
+      return vaultPriceLs(flags);
+    case "rm":
+      return vaultPriceRm(args.slice(1), flags);
+    default:
+      error(`Unknown price command: ${action ?? "(none)"}. Use: set, get, ls, rm`);
+  }
+}
+async function vaultPriceSet(args, flags) {
+  const [path, amount] = args;
+  if (!path || !amount)
+    error("Usage: orbitmem vault price set <path> <amount>");
+  const config = loadConfig();
+  if (flags.relay)
+    config.relay = flags.relay;
+  const client = await createClient(config);
+  try {
+    const currency = flags.currency ?? "USDC";
+    await client.pricing.setPrice(path, { amount, currency });
+    if (flags.json !== undefined) {
+      output({ path, amount, currency }, true);
+    } else {
+      process.stdout.write(`Set price for "${path}": ${amount} ${currency} per read
+`);
+    }
+  } finally {
+    await client.destroy();
+  }
+}
+async function vaultPriceGet(args, flags) {
+  const [path] = args;
+  if (!path)
+    error("Usage: orbitmem vault price get <path>");
+  const config = loadConfig();
+  if (flags.relay)
+    config.relay = flags.relay;
+  const client = await createClient(config);
+  try {
+    const price = await client.pricing.getPrice(path);
+    if (!price) {
+      if (flags.json !== undefined) {
+        output(null, true);
+      } else {
+        process.stdout.write(`"${path}" is free (no pricing set)
+`);
+      }
+    } else if (flags.json !== undefined) {
+      output({ path, ...price }, true);
+    } else {
+      process.stdout.write(`${price.amount} ${price.currency}
+`);
+    }
+  } finally {
+    await client.destroy();
+  }
+}
+async function vaultPriceLs(flags) {
+  const config = loadConfig();
+  if (flags.relay)
+    config.relay = flags.relay;
+  const client = await createClient(config);
+  try {
+    const prices = await client.pricing.listPrices();
+    if (flags.json !== undefined) {
+      output(prices, true);
+    } else if (prices.length === 0) {
+      process.stdout.write(`(no priced paths)
+`);
+    } else {
+      for (const p of prices) {
+        process.stdout.write(`${p.path}	${p.amount} ${p.currency}
+`);
+      }
+    }
+  } finally {
+    await client.destroy();
+  }
+}
+async function vaultPriceRm(args, flags) {
+  const [path] = args;
+  if (!path)
+    error("Usage: orbitmem vault price rm <path>");
+  const config = loadConfig();
+  if (flags.relay)
+    config.relay = flags.relay;
+  const client = await createClient(config);
+  try {
+    await client.pricing.removePrice(path);
+    if (flags.json !== undefined) {
+      output({ path, removed: true }, true);
+    } else {
+      process.stdout.write(`Removed pricing for "${path}"
+`);
+    }
+  } finally {
+    await client.destroy();
+  }
+}
+var init_vault = __esm(() => {
+  init_config();
+  init_client();
+});
+
+// src/commands/register.ts
+var exports_register = {};
+__export(exports_register, {
+  register: () => register
+});
+async function register(args, flags) {
+  const [path] = args;
+  if (!path)
+    error("Usage: orbitmem register <path>");
+  const config = loadConfig();
+  if (flags.relay)
+    config.relay = flags.relay;
+  if (!config.registryAddress)
+    error("No registry address configured. Set registryAddress in ~/.orbitmem/config.json");
+  const client = await createClient(config);
+  try {
+    const entry = await client.vault.get(path);
+    if (!entry)
+      error(`Vault entry not found: ${path}`);
+    const result = await client.discovery.registerData({
+      key: path,
+      name: flags.name ?? path,
+      description: flags.description ?? "",
+      schema: flags.schema,
+      tags: flags.tags ? flags.tags.split(",") : []
+    });
+    if (flags.json !== undefined) {
+      output(result, true);
+    } else {
+      process.stdout.write(`Registered "${path}" on-chain
+`);
+      process.stdout.write(`  Data ID: ${result.dataId}
+`);
+    }
+  } finally {
+    await client.destroy();
+  }
+}
+var init_register = __esm(() => {
+  init_config();
+  init_client();
+});
+
+// src/commands/discover.ts
+var exports_discover = {};
+__export(exports_discover, {
+  discover: () => discover
+});
+async function discover(args, flags) {
+  const config = loadConfig();
+  if (flags.relay)
+    config.relay = flags.relay;
+  if (!config.registryAddress)
+    error("No registry address configured. Set registryAddress in ~/.orbitmem/config.json");
+  const client = await createClient(config);
+  try {
+    const query = {};
+    if (args[0])
+      query.schema = args[0];
+    if (flags.tags)
+      query.tags = flags.tags.split(",");
+    if (flags["min-quality"])
+      query.minQuality = Number(flags["min-quality"]);
+    const results = await client.discovery.findData(query);
+    if (flags.json !== undefined) {
+      output(results, true);
+    } else if (results.length === 0) {
+      process.stdout.write(`No data found
+`);
+    } else {
+      const rows = results.map((r) => ({
+        id: r.dataId,
+        name: r.name,
+        quality: r.quality,
+        vault: `${String(r.vaultAddress ?? "").slice(0, 10)}...`
+      }));
+      output(rows, false);
+    }
+  } finally {
+    await client.destroy();
+  }
+}
+var init_discover = __esm(() => {
+  init_config();
+  init_client();
+});
+
+// src/commands/snapshot.ts
+var exports_snapshot = {};
+__export(exports_snapshot, {
+  snapshot: () => snapshot
+});
+async function snapshot(_args, flags) {
+  const config = loadConfig();
+  if (flags.relay)
+    config.relay = flags.relay;
+  const client = await createClient(config);
+  try {
+    const result = await client.persistence.archive({
+      label: flags.label
+    });
+    if (flags.json !== undefined) {
+      output(result, true);
+    } else {
+      process.stdout.write(`Snapshot archived!
+`);
+      process.stdout.write(`  CID:     ${result.cid}
+`);
+      process.stdout.write(`  Size:    ${result.size} bytes
+`);
+      process.stdout.write(`  Entries: ${result.entryCount}
+`);
+    }
+  } finally {
+    await client.destroy();
+  }
+}
+var init_snapshot = __esm(() => {
+  init_config();
+  init_client();
+});
+
+// src/commands/dev.ts
+var exports_dev = {};
+__export(exports_dev, {
+  dev: () => dev
+});
+async function dev(_args, flags) {
+  const port = flags.port ? Number(flags.port) : 3000;
+  process.stdout.write(`Starting OrbitMem relay on http://localhost:${port}...
+`);
+  const { buildApp } = await import("@orbitmem/relay/app");
+  const { createMockServices } = await import("@orbitmem/relay/services");
+  const { serve } = await import("@hono/node-server");
+  const services = createMockServices();
+  const app = buildApp(services);
+  const server = serve({
+    fetch: app.fetch,
+    port
+  });
+  process.stdout.write(`Relay running at http://localhost:${port}
+`);
+  process.stdout.write(`Press Ctrl+C to stop
+
+`);
+  process.on("SIGINT", () => {
+    process.stdout.write(`
+Shutting down...
+`);
+    server.close();
+    process.exit(0);
+  });
+}
+
+// src/index.ts
+function parseArgs(argv) {
+  const raw = argv.slice(2);
+  const flags = {};
+  const positional = [];
+  for (let i = 0;i < raw.length; i++) {
+    if (raw[i].startsWith("--")) {
+      const key = raw[i].slice(2);
+      const next = raw[i + 1];
+      if (next && !next.startsWith("--")) {
+        flags[key] = next;
+        i++;
+      } else {
+        flags[key] = "";
+      }
+    } else {
+      positional.push(raw[i]);
+    }
+  }
+  return {
+    command: positional[0] ?? "help",
+    args: positional.slice(1),
+    flags
+  };
+}
+function printUsage() {
+  process.stdout.write(`
+Usage: orbitmem <command> [options]
+
+Commands:
+  init                       Generate keys and create config
+  status                     Show identity, config, and vault info
+  vault store <path> <value> Store data in vault
+  vault get <path>           Read data from vault
+  vault ls [prefix]          List vault keys
+  vault update-access <path> Re-encrypt with new Lit access conditions
+  vault price set <path> <amount>  Set per-read price (USDC)
+  vault price get <path>           Show price for path
+  vault price ls                   List all priced paths
+  vault price rm <path>            Remove pricing (free)
+  register <path>            Register data on-chain (ERC-8004)
+  discover [query]           Search on-chain registries
+  snapshot                   Persist vault to Storacha
+  dev                        Start local relay server
+
+Options:
+  --relay <url>           Override relay URL
+  --chain <name>          Override chain
+  --json                  Output as JSON
+  --help                  Show this help
+
+Vault store options:
+  --public                Store as public (unencrypted)
+  --shared                Store as shared (encrypted, condition-gated)
+  --engine <aes|lit>      Encryption engine (default: aes)
+  --lit-network <name>    Lit network: cayenne | manzano | habanero (default: cayenne)
+  --allow-address <addr>  Lit: allow this address to decrypt
+  --min-score <n>         Lit: require minimum reputation score to decrypt
+  --access-chain <chain>  Lit: chain for access conditions (default: base-sepolia)
+
+`);
+}
+async function main() {
+  const { command, args, flags } = parseArgs(process.argv);
+  if (flags.help !== undefined || command === "help") {
+    printUsage();
+    return;
+  }
+  switch (command) {
+    case "init": {
+      const { init: init2 } = await Promise.resolve().then(() => (init_init(), exports_init));
+      await init2(args, flags);
+      break;
+    }
+    case "status": {
+      const { status: status2 } = await Promise.resolve().then(() => (init_status(), exports_status));
+      await status2(args, flags);
+      break;
+    }
+    case "vault": {
+      const { vault: vault2 } = await Promise.resolve().then(() => (init_vault(), exports_vault));
+      await vault2(args, flags);
+      break;
+    }
+    case "register": {
+      const { register: register2 } = await Promise.resolve().then(() => (init_register(), exports_register));
+      await register2(args, flags);
+      break;
+    }
+    case "discover": {
+      const { discover: discover2 } = await Promise.resolve().then(() => (init_discover(), exports_discover));
+      await discover2(args, flags);
+      break;
+    }
+    case "snapshot": {
+      const { snapshot: snapshot2 } = await Promise.resolve().then(() => (init_snapshot(), exports_snapshot));
+      await snapshot2(args, flags);
+      break;
+    }
+    case "dev": {
+      const { dev: dev2 } = await Promise.resolve().then(() => exports_dev);
+      await dev2(args, flags);
+      break;
+    }
+    default:
+      process.stderr.write(`Unknown command: ${command}
+`);
+      printUsage();
+      process.exit(1);
+  }
+}
+main().catch((err) => {
+  process.stderr.write(`error: ${err.message}
+`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@orbitmem/cli",
+  "version": "0.1.0",
+  "description": "CLI for OrbitMem — manage vaults, discover data, and interact with on-chain registries",
+  "keywords": [
+    "agents",
+    "ai",
+    "cli",
+    "data",
+    "orbitmem",
+    "vault",
+    "web3"
+  ],
+  "homepage": "https://github.com/oboroxyz/orbitmem/tree/main/packages/cli",
+  "license": "MIT",
+  "author": "Oboro Inc. <dev@oboro.xyz> (https://oboro.xyz)",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/oboroxyz/orbitmem",
+    "directory": "packages/cli"
+  },
+  "bin": {
+    "orbitmem": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "scripts": {
+    "build": "bun build ./src/index.ts --outdir ./dist --target node --packages external",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "bun run build"
+  },
+  "dependencies": {
+    "@hono/node-server": "^1.13.0",
+    "@open-wallet-standard/core": "^1.1.0",
+    "@orbitmem/relay": "^0.1.0",
+    "@orbitmem/sdk": "^0.1.0",
+    "viem": "^2.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.4.0",
+    "bun-types": "latest",
+    "typescript": "^5.5.0"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}