sella-cli 0.7.0 → 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>
@@ -79,6 +79,7 @@ What's in there: a catalogue of 1,100+ machine-payable API providers, plus first
 - **Pay-per-call in USDC**: fractions of a cent for most calls, multi-chain, with budgets you set and keys you can revoke.
 - **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.
 
@@ -92,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. |
@@ -121,6 +123,20 @@ Then ask your agent:
 
 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
 
 ```bash
@@ -205,7 +221,7 @@ 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 |

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/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.7.0';
+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'
@@ -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.7.0",
+  "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",