sella-cli 0.6.6 → 0.8.0

package/README.md

@@ -18,7 +18,7 @@
 
 <p align="center">
   <a href="https://sellag.vercel.app">Website</a> ·
-  <a href="https://sella.mintlify.app">Docs</a> ·
+  <a href="https://docs.selltoagent.dev">Docs</a> ·
   <a href="https://sellag.vercel.app/marketplace">Marketplace</a> ·
   <a href="https://github.com/010100100100011101010100/ogsella/issues">Report a bug</a>
 </p>
@@ -33,7 +33,7 @@ npx sella-cli
 
 That one command is the whole setup. The wizard:
 
-1. **Detects your agent clients**: Claude Code, Claude Desktop, Cursor, Windsurf, VS Code, Cline.
+1. **Detects your agent clients**: Claude Code, Claude Desktop, Cursor, Windsurf, VS Code, Cline, Codex, Antigravity, OpenClaw.
 2. **Installs the Sella MCP server** into each one. Writes are idempotent and your other MCP servers are preserved.
 3. **Pairs the machine**: paste a setup code from the dashboard, or use your email and a 6-digit code.
 4. **Proves it works** with a live `sella doctor` run at the end.
@@ -77,7 +77,9 @@ What's in there: a catalogue of 1,100+ machine-payable API providers, plus first
 
 - **One-command onboarding**, so you never hand-edit an MCP config again.
 - **Pay-per-call in USDC**: fractions of a cent for most calls, multi-chain, with budgets you set and keys you can revoke.
-- **A marketplace built for agents**: every listing is discoverable and payable over MCP + x402, so your agent buys mid-task instead of stalling.
+- **One search across everything**: datasets, APIs, workflows, and Sella Native products are all discoverable in a single MCP call, ranked by computed quality, so your agent buys mid-task instead of stalling.
+- **Policy-aware buying**: your agent can preview a quote and check it against your budget before paying, and every purchase leaves a decision receipt it can explain.
+- **Businesses**: your agent can open a named run before it starts work, and everything it buys, calls, and decides gets attached to that run. You see what a piece of work actually cost instead of one undifferentiated spend total. Run `sella businesses` to read them from the terminal.
 - **Publishing from a CSV**, so you can sell your own data without opening a browser.
 - **Agent-grade output**: every command supports `--json`, `--yes`, and env vars, with meaningful exit codes. Your CI can run it. Your agent can run it.
 
@@ -91,6 +93,7 @@ What's in there: a catalogue of 1,100+ machine-payable API providers, plus first
 | `sella clients` | List detected agent clients. `--install` writes configs, `--client a,b` filters, `--dry-run` previews. |
 | `sella doctor` | Six live checks, from endpoint reachability to a real x402 pay quote. Every failure names its fix. |
 | `sella status` | Your API key and agent wallet balances, each chain labelled live or deposit-only. |
+| `sella businesses` | Your agent's named runs, newest first: status, spend, tool calls, and the outcome it wrote. `--active` or `--closed` filters. |
 | `sella fund` | Per-chain USDC deposit addresses, plus the funding page with QR codes and a fiat on-ramp. |
 | `sella mcp` | Run a local stdio MCP server that proxies Sella with your stored key, for clients that cannot use a remote endpoint. |
 | `sella publish init <file.csv>` | Scaffold `sella-dataset.json` and pre-check the CSV structure. |
@@ -118,7 +121,21 @@ Then ask your agent:
 
 > Search Sella for a web search API and tell me what it costs per call.
 
-The agent answers using the Sella MCP tools (`search_datasets`, `list_market_apis`, `try_dataset`, and friends) with the key this CLI stored for it. When you fund the agent wallet, it can buy what it found.
+The agent answers using Sella's MCP tools, starting with `search_catalog` (one search across datasets, APIs, workflows, and Sella Native products) and `get_listing` for the details, with the key this CLI stored for it. When you fund the agent wallet, it can preview the price with `purchase_preview` and buy what it found.
+
+### Keep track of what a piece of work cost
+
+Ask your agent to open a business before it starts:
+
+> Start a Sella business called "Q3 pricing research", then find me comparable pricing datasets under $20.
+
+It calls `business_start`, and from that point every Sella call it makes is attached to that run. When it finishes it closes the run with a summary. Then:
+
+```bash
+sella businesses
+```
+
+You get each run with its spend, tool-call count, and the outcome the agent wrote, instead of a single spend figure you cannot attribute to anything. A business is a label over the agent wallet you already funded, so there are no extra wallets, keys, or balances to manage.
 
 ### Real-world: publish a CSV and get paid in USDC
 
@@ -204,15 +221,16 @@ Sella has two other ways in: your agent can onboard itself over MCP with your em
 | | |
 |---|---|
 | Website | https://sellag.vercel.app |
-| Docs | https://sella.mintlify.app |
+| Docs | https://docs.selltoagent.dev |
 | Marketplace | https://sellag.vercel.app/marketplace |
 | Agent task ideas | https://sellag.vercel.app/rfi |
 | npm | https://www.npmjs.com/package/sella-cli |
 | Issues | https://github.com/010100100100011101010100/ogsella/issues |
+| Email | rasesh@buildifi.ai |
 
 ## Found a bug?
 
-Found a bug? Have an idea? [Mail us](rasesh@buildifi.ai). We read every one.
+Found a bug? Have an idea? [Open an issue](https://github.com/010100100100011101010100/ogsella/issues) or [email us](mailto:rasesh@buildifi.ai). We read every one.
 
 ## License
 

package/dist/api.js

@@ -3,12 +3,15 @@
  * the CLI speaks the exact same tools/call surface agents use (sella_setup_claim,
  * sella_auth_start/complete), so CLI, web, and agent onboarding cannot drift.
  */
-export async function callToolRaw(mcpUrl, name, args, fetchImpl = fetch) {
+export async function callToolRaw(mcpUrl, name, args, fetchImpl = fetch, apiKey) {
     let res;
     try {
         res = await fetchImpl(mcpUrl, {
             method: 'POST',
-            headers: { 'content-type': 'application/json' },
+            headers: {
+                'content-type': 'application/json',
+                ...(apiKey ? { authorization: `Bearer ${apiKey}` } : {}),
+            },
             body: JSON.stringify({ jsonrpc: '2.0', id: name, method: 'tools/call', params: { name, arguments: args } }),
         });
     }
@@ -17,7 +20,9 @@ export async function callToolRaw(mcpUrl, name, args, fetchImpl = fetch) {
             'Check your connection, proxy settings, or SELLA_MCP_URL.');
     }
     if (res.status === 429) {
-        throw new Error('Sandbox rate limit reached. Run `sella pair` for unmetered access.');
+        throw new Error(apiKey
+            ? 'Sella rate limit reached. Wait a moment and try again.'
+            : 'Sandbox rate limit reached. Run `sella pair` for unmetered access.');
     }
     if (!res.ok) {
         throw new Error(`Sella endpoint at ${mcpUrl} responded ${res.status}. Check SELLA_MCP_URL.`);
@@ -38,24 +43,60 @@ export async function callToolRaw(mcpUrl, name, args, fetchImpl = fetch) {
     throw new Error('Unexpected response shape from the Sella MCP endpoint.');
 }
 export const callAuthTool = (mcpUrl, name, args, fetchImpl = fetch) => callToolRaw(mcpUrl, name, args, fetchImpl);
-/** Zero-identity demo: read-only free tools only (list_market_apis + search_datasets). */
+/** Price on a search_catalog result is `{ amountUSDC, minUSDC, ... }`; older shapes were a number. */
+function priceUSDCOf(entry) {
+    const raw = entry?.price ?? entry?.priceUSDC;
+    const n = typeof raw === 'number' ? raw : Number(raw?.amountUSDC ?? raw?.minUSDC);
+    return Number.isFinite(n) ? n : undefined;
+}
+/**
+ * Zero-identity demo: ONE free `search_catalog` call across every listing kind.
+ *
+ * Replaces the previous pair of calls to `search_datasets` + `list_market_apis` (both deprecated
+ * aliases scheduled for removal, and the latter reads a backend that can be empty or asleep).
+ * One call now covers datasets, APIs, workflows and Sella Native products, so the sandbox shows
+ * the same ranked surface an agent sees.
+ */
 export async function sandboxSearch(mcpUrl, query, fetchImpl = fetch) {
-    // Tolerate a single tool being flaky, but never swallow the rate limit — that's what the user
-    // needs to see (it tells them to pair).
-    const soft = (err) => {
-        if (err instanceof Error && /rate limit/i.test(err.message))
-            throw err;
-        return {};
-    };
-    const [datasets, apis] = await Promise.all([
-        callToolRaw(mcpUrl, 'search_datasets', { query, limit: 5 }, fetchImpl).catch(soft),
-        callToolRaw(mcpUrl, 'list_market_apis', { query, limit: 5 }, fetchImpl).catch(soft),
-    ]);
-    // search_datasets returns the array directly; list_market_apis wraps it in `catalogue`.
-    const asArray = (v, ...keys) => Array.isArray(v) ? v : keys.map((k) => v?.[k]).find(Array.isArray) || [];
+    const payload = await callToolRaw(mcpUrl, 'search_catalog', { query, limit: 10 }, fetchImpl);
+    const results = Array.isArray(payload?.results)
+        ? payload.results
+        : Array.isArray(payload)
+            ? payload
+            : [];
+    const datasets = results
+        .filter((r) => r?.kind === 'dataset')
+        .slice(0, 5)
+        .map((r) => ({
+        id: String(r?.id ?? ''),
+        title: r?.title,
+        tier: r?.attributes?.tier,
+        priceUSDC: priceUSDCOf(r),
+    }));
+    // Everything that is not a dataset (api, workflow, native) prints in the "api" column.
+    const apis = results
+        .filter((r) => r?.kind && r.kind !== 'dataset')
+        .slice(0, 5)
+        .map((r) => ({
+        name: r?.title,
+        description: r?.description,
+        priceUSDC: priceUSDCOf(r),
+        chains: Array.isArray(r?.chains) ? r.chains : undefined,
+    }));
+    return { datasets, apis };
+}
+/**
+ * `business_list`: the caller's named agent runs, newest first. Businesses label the existing
+ * agent wallet rather than creating new ones, so this is a read over the same key the CLI stored.
+ */
+export async function listBusinesses(mcpUrl, apiKey, args = {}, fetchImpl = fetch) {
+    const payload = await callToolRaw(mcpUrl, 'business_list', { ...args }, fetchImpl, apiKey);
+    if (payload?.error)
+        throw new Error(String(payload.error));
     return {
-        datasets: asArray(datasets, 'datasets', 'results').slice(0, 5),
-        apis: asArray(apis, 'catalogue', 'providers', 'apis', 'results').slice(0, 5),
+        businesses: Array.isArray(payload?.businesses) ? payload.businesses : [],
+        active: payload?.active ?? null,
+        count: Number(payload?.count ?? 0),
     };
 }
 export const claimSetupCode = (mcpUrl, code, fetchImpl) => callAuthTool(mcpUrl, 'sella_setup_claim', { code, client: 'sella-cli' }, fetchImpl);

package/dist/clients.js

@@ -27,6 +27,27 @@ function stdioBridgeEntry(mcpUrl, apiKey) {
         args: ['-y', 'mcp-remote', mcpUrl, ...(apiKey ? ['--header', `Authorization: Bearer ${apiKey}`] : [])],
     };
 }
+/**
+ * Codex keeps MCP servers in ~/.codex/config.toml. We do a targeted section upsert instead of a
+ * TOML parse/serialize round-trip so user comments and formatting survive. The `url` key selects
+ * streamable HTTP; `http_headers` carries static auth headers (both per the Codex config docs).
+ * Only the standard `[mcp_servers.sella]` table form is recognized; exotic spellings (dotted keys,
+ * inline tables) are left alone and would shadow ours — the backup covers that case.
+ */
+export function upsertCodexToml(raw, mcpUrl, apiKey) {
+    const lines = [`[mcp_servers.sella]`, `url = "${mcpUrl}"`];
+    if (apiKey)
+        lines.push(`http_headers = { "Authorization" = "Bearer ${apiKey}" }`);
+    const section = lines.join('\n');
+    // Our table (plus any of its sub-tables) up to the next unrelated header or end of file.
+    const existing = /(^|\n)\[mcp_servers\.sella\][\s\S]*?(?=\n\[(?!mcp_servers\.sella[.\]])|$)/;
+    if (existing.test(raw)) {
+        const next = raw.replace(existing, (_match, lead) => `${lead}${section}`);
+        return next.endsWith('\n') ? next : `${next}\n`;
+    }
+    const head = raw.trimEnd();
+    return `${head ? `${head}\n\n` : ''}${section}\n`;
+}
 const CLIENTS = [
     {
         id: 'claude-code',
@@ -91,6 +112,43 @@ const CLIENTS = [
             doc.mcpServers.sella = stdioBridgeEntry(mcpUrl, apiKey);
         },
     },
+    {
+        id: 'codex',
+        name: 'Codex',
+        marker: (env) => path.join(env.home, '.codex'),
+        configPath: (env) => path.join(env.home, '.codex', 'config.toml'),
+        applyRaw: upsertCodexToml,
+    },
+    {
+        // Antigravity IDE + CLI share one MCP config at ~/.gemini/config/mcp_config.json.
+        // Remote servers use `serverUrl` (`httpUrl` is deprecated).
+        id: 'antigravity',
+        name: 'Antigravity',
+        marker: (env) => appSupport(env, 'Antigravity'),
+        configPath: (env) => path.join(env.home, '.gemini', 'config', 'mcp_config.json'),
+        apply: (doc, mcpUrl, apiKey) => {
+            doc.mcpServers = doc.mcpServers || {};
+            const entry = { serverUrl: mcpUrl };
+            if (apiKey)
+                entry.headers = { Authorization: `Bearer ${apiKey}` };
+            doc.mcpServers.sella = entry;
+        },
+    },
+    {
+        // OpenClaw stores MCP servers under mcp.servers in ~/.openclaw/openclaw.json.
+        id: 'openclaw',
+        name: 'OpenClaw',
+        marker: (env) => path.join(env.home, '.openclaw'),
+        configPath: (env) => path.join(env.home, '.openclaw', 'openclaw.json'),
+        apply: (doc, mcpUrl, apiKey) => {
+            doc.mcp = doc.mcp || {};
+            doc.mcp.servers = doc.mcp.servers || {};
+            const entry = { url: mcpUrl, transport: 'streamable-http' };
+            if (apiKey)
+                entry.headers = { Authorization: `Bearer ${apiKey}` };
+            doc.mcp.servers.sella = entry;
+        },
+    },
 ];
 export function detectClients(env = defaultEnv()) {
     return CLIENTS.map((spec) => ({
@@ -108,6 +166,25 @@ export function installSellaIntoClient(id, opts) {
         throw new Error(`Unknown client: ${id}`);
     const configPath = spec.configPath(env);
     const exists = fs.existsSync(configPath);
+    // Raw-text configs (Codex's TOML): targeted rewrite, byte-compare for idempotency.
+    if (spec.applyRaw) {
+        const raw = exists ? fs.readFileSync(configPath, 'utf8') : '';
+        const next = spec.applyRaw(raw, opts.mcpUrl, opts.apiKey);
+        if (exists && raw === next) {
+            return { id, configPath, action: 'unchanged' };
+        }
+        let backupPath;
+        if (!opts.dryRun) {
+            fs.mkdirSync(path.dirname(configPath), { recursive: true });
+            if (exists && raw.trim()) {
+                backupPath = `${configPath}.sella-backup`;
+                if (!fs.existsSync(backupPath))
+                    fs.writeFileSync(backupPath, raw);
+            }
+            fs.writeFileSync(configPath, next);
+        }
+        return { id, configPath, action: exists ? 'updated' : 'created', backupPath };
+    }
     let doc = {};
     if (exists) {
         const raw = fs.readFileSync(configPath, 'utf8').trim();
@@ -121,6 +198,8 @@ export function installSellaIntoClient(id, opts) {
         }
     }
     const before = JSON.stringify(doc);
+    if (!spec.apply)
+        throw new Error(`Client ${id} has no config writer`);
     spec.apply(doc, opts.mcpUrl, opts.apiKey);
     const after = JSON.stringify(doc, null, 2);
     if (exists && JSON.stringify(JSON.parse(before)) === JSON.stringify(JSON.parse(after))) {

package/dist/doctor.js

@@ -91,7 +91,10 @@ export async function runDoctor(opts) {
     // 4. auth — the stored key actually authenticates a protected call
     if (stored) {
         try {
-            const called = await rpc(opts.mcpUrl, { method: 'tools/call', params: { name: 'list_datasets', arguments: { limit: 1 } } }, fetchImpl, stored.apiKey);
+            const called = await rpc(opts.mcpUrl, 
+            // search_catalog, not the deprecated list_datasets alias: this check must outlive the
+            // one-release deprecation window for the legacy discovery names.
+            { method: 'tools/call', params: { name: 'search_catalog', arguments: { limit: 1 } } }, fetchImpl, stored.apiKey);
             const isError = Boolean(called?.result?.isError) || Boolean(called?.error);
             checks.push({
                 id: 'auth',

package/dist/index.js

@@ -6,14 +6,14 @@ import { pair } from './pairing.js';
 import { runDoctor, runStatus, loadStoredKey } from './doctor.js';
 import { runMcpBridge } from './mcp-bridge.js';
 import { scaffoldCard, pushDataset, CARD_FILENAME } from './publish.js';
-import { sandboxSearch } from './api.js';
+import { sandboxSearch, listBusinesses } from './api.js';
 import { getFundingInfo, annotateFunding } from './fund.js';
 import { capabilityLabel } from './chains.js';
 import { defaultIo, Printer } from './output.js';
 import { Ui } from './ui.js';
 import { recordCliEvent, saveTelemetryDecision, shouldPromptTelemetry } from './telemetry.js';
 const DEFAULT_MCP_URL = 'https://sellag.vercel.app/api/mcp';
-const VERSION = '0.6.6';
+const VERSION = '0.8.0';
 function parseFlags(argv) {
     const flags = {
         json: false, yes: false, noColor: false, dryRun: false, noKeychain: false,
@@ -62,6 +62,7 @@ Commands:
   clients    List detected agent clients (--install to write configs)
   doctor     Verify the install: endpoint, credentials, auth, wallets, pay-quote
   status     Show your key + AgentWallet balances
+  businesses Show your agent's named runs: spend, tool calls, outcome
   fund       Show deposit addresses + funding links to add USDC to your agent wallet
   mcp        Run as a local stdio MCP server that proxies Sella with your stored key
   publish    Publish a dataset from a CSV: 'publish init <file.csv>' then 'publish push'
@@ -70,7 +71,7 @@ Options:
   --setup-code <code>   Pair with a dashboard setup code (also: SELLA_SETUP_CODE env)
   --email <address>     Pair with email + OTP (interactive)
   --card <path>         Dataset card for 'publish push' (default ./sella-dataset.json)
-  --client <ids>        Comma-separated subset (claude-code,claude-desktop,cursor,windsurf,vscode,cline)
+  --client <ids>        Comma-separated subset (claude-code,claude-desktop,cursor,windsurf,vscode,cline,codex,antigravity,openclaw)
   --no-keychain         Skip the OS keychain; store the key in a 0600 file (also: SELLA_NO_KEYCHAIN)
   --dry-run             Show what would change without writing
   --json                Machine-readable output (one JSON document on stdout)
@@ -86,7 +87,7 @@ Environment:
 
 Links:
   Website   https://sellag.vercel.app
-  Docs      https://sella.mintlify.app
+  Docs      https://docs.selltoagent.dev
   Issues    https://github.com/010100100100011101010100/ogsella/issues
 `;
 function selectClientIds(flags, detected) {
@@ -339,7 +340,7 @@ export async function runCli(argv, io = defaultIo(), env = defaultEnv()) {
         io.stdout(VERSION);
         // TTY-only: scripts capturing `sella --version` must still get a bare semver.
         if (io.isTTY)
-            io.stdout('docs: https://sella.mintlify.app · issues: https://github.com/010100100100011101010100/ogsella/issues');
+            io.stdout('docs: https://docs.selltoagent.dev · issues: https://github.com/010100100100011101010100/ogsella/issues');
         return 0;
     }
     if (flags.help) {
@@ -483,6 +484,43 @@ export async function runCli(argv, io = defaultIo(), env = defaultEnv()) {
                 }
                 return 0;
             }
+            case 'businesses': {
+                const stored = loadStoredKey(ctx.env);
+                if (!stored) {
+                    printer.error('Not paired yet. Run `sella pair` (or `sella init`) first.');
+                    return 2;
+                }
+                const statusFlag = flags.positional.includes('--active')
+                    ? 'active'
+                    : flags.positional.includes('--closed')
+                        ? 'closed'
+                        : undefined;
+                const result = await listBusinesses(ctx.mcpUrl, stored.apiKey, {
+                    limit: 20,
+                    ...(statusFlag ? { status: statusFlag } : {}),
+                });
+                printer.jsonOut(result);
+                if (!flags.json) {
+                    if (!result.businesses.length) {
+                        printer.info('No businesses yet. Ask your agent to start one before it works:\n' +
+                            '  "Start a Sella business called <name>, then research X."');
+                        return 0;
+                    }
+                    printer.info(`Your agent's runs (${result.count}):`);
+                    for (const b of result.businesses) {
+                        const t = b.totals || {};
+                        const spend = `$${Number(t.spendUSDC || 0).toFixed(2)}`;
+                        const mark = b.status === 'active' ? '●' : '·';
+                        printer.info(`  ${mark} ${b.name}`);
+                        printer.info(`      ${String(b.status).padEnd(7)} ${spend.padStart(8)}  ${String(t.toolCalls || 0).padStart(4)} calls  ${b.businessId}`);
+                        const summary = b.outcome || b.goal;
+                        if (summary)
+                            printer.info(`      ${summary.length > 88 ? `${summary.slice(0, 88)}…` : summary}`);
+                    }
+                    printer.info('\nFull detail: https://sellag.vercel.app/dashboard/businesses');
+                }
+                return 0;
+            }
             case 'publish': {
                 const sub = flags.positional[1];
                 const origin = ctx.mcpUrl.replace(/\/api\/mcp\/?$/, '') || 'https://sellag.vercel.app';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sella-cli",
-  "version": "0.6.6",
+  "version": "0.8.0",
   "description": "Connect your AI agent to Sella, the marketplace where agents buy data and APIs, in one command: npx sella-cli. Installs the Sella MCP server into Claude Code, Cursor and more, then pairs, verifies, funds, and publishes.",
   "keywords": [
     "cli",