sella-cli 0.7.0 → 0.9.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>
@@ -71,7 +71,7 @@ npx sella-cli sandbox "web search"
   <img src="https://sellag.vercel.app/readme/cli-sandbox.svg" alt="sella sandbox returns live marketplace results: Exa, Tavily and more, with no account" width="740" />
 </p>
 
-What's in there: a catalogue of 1,100+ machine-payable API providers, plus first-party datasets, workflows, and Sella Native products such as Cradle. Free previews let your agent check quality before it pays.
+What's in there: a catalogue of 1,500+ machine-payable API providers with 8,000+ verified callable endpoints, plus first-party datasets, workflows, and Sella Native products such as Cradle. Free previews let your agent check quality before it pays.
 
 ## What you get
 
@@ -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,15 @@ 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 { skillStatus, syncSkillBundle } from './skill.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 +63,8 @@ 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
+  skill      Show the cached agent instruction bundle; 'skill update' refreshes it
   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 +89,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) {
@@ -289,6 +292,17 @@ async function cmdInit(ctx, flags, printer) {
             sp.fail('Verify could not run (network?) — try `sella doctor` later.');
             verifySummary = { ok: false, error: err instanceof Error ? err.message : String(err) };
         }
+        // Cache the agent instruction bundle alongside the credentials, so the agent reads its
+        // instructions from disk instead of re-fetching them every session. Best effort on purpose:
+        // onboarding must not fail because a documentation download did, and `sella skill update`
+        // fixes it later.
+        try {
+            const bundle = await syncSkillBundle({ env: ctx.env, origin });
+            ui.detail(`Skill bundle ${bundle.version} cached at ${bundle.dir}`);
+        }
+        catch {
+            ui.detail('Skill bundle not cached (network?). Run `sella skill update` later.');
+        }
     }
     if (paired.code === 0) {
         const awStatus = String(paired.summary?.agentWallet || 'none');
@@ -339,7 +353,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 +497,84 @@ export async function runCli(argv, io = defaultIo(), env = defaultEnv()) {
                 }
                 return 0;
             }
+            case 'skill': {
+                const origin = ctx.mcpUrl.replace(/\/api\/mcp\/?$/, '');
+                const sub = flags.positional[1];
+                if (sub === 'update') {
+                    const result = await syncSkillBundle({ env: ctx.env, origin, force: flags.positional.includes('--force') });
+                    printer.jsonOut(result);
+                    if (!flags.json) {
+                        if (result.upToDate) {
+                            printer.info(`Already on ${result.version}. Nothing to download.`);
+                        }
+                        else {
+                            const moved = result.previousVersion ? `${result.previousVersion} -> ${result.version}` : result.version;
+                            printer.info(`Skill bundle ${moved}`);
+                            printer.info(`  ${result.written.length} downloaded, ${result.reused.length} unchanged`);
+                            printer.info(`  ${result.dir}`);
+                        }
+                    }
+                    return 0;
+                }
+                const status = await skillStatus(ctx.env, origin);
+                printer.jsonOut(status);
+                if (!flags.json) {
+                    if (!status.localVersion) {
+                        printer.info(`No local bundle. Live version is ${status.remoteVersion}.`);
+                        printer.info('Run `sella skill update` to cache it.');
+                    }
+                    else if (status.upToDate) {
+                        printer.info(`Skill bundle ${status.localVersion} (current).`);
+                        if (status.dir)
+                            printer.info(`  ${status.dir}`);
+                    }
+                    else {
+                        printer.info(`Skill bundle ${status.localVersion} is out of date. Live version is ${status.remoteVersion}.`);
+                        if (status.breaking) {
+                            printer.info('  This is a breaking change: a tool may have been removed or changed.');
+                        }
+                        printer.info('  Run `sella skill update`.');
+                    }
+                }
+                return status.localVersion && !status.upToDate ? 1 : 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/dist/skill.js

@@ -0,0 +1,169 @@
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+/**
+ * Local skill-bundle cache.
+ *
+ * An agent that re-fetches 25 KB of instructions every session burns context and gets whatever is
+ * live, which can change mid-task. A pinned local copy is cheaper and reproducible: two runs of the
+ * same prompt read the same instructions, so when something goes wrong you know which version
+ * produced it.
+ *
+ * The danger is the obvious one. A cache that never expires is a confidently wrong copy of a world
+ * that moved, which is exactly how the old hand-written skill.json ended up advertising four
+ * deprecated tools. So the bundle is stored under its version, the server stamps stale callers on
+ * calls they were already making, and `sella skill update` is one command.
+ */
+/** Placeholder the server substitutes per request host. See lib/agent-docs.ts. */
+const ORIGIN_PLACEHOLDER = '{{SELLA_ORIGIN}}';
+export class SkillSyncError extends Error {
+}
+function skillRoot(env) {
+    return path.join(env.home, '.sella', 'skill');
+}
+function pointerPath(env) {
+    return path.join(skillRoot(env), 'current');
+}
+/**
+ * A plain text pointer rather than a symlink. Symlink creation needs elevation or developer mode on
+ * Windows, and this has to work for every operator, not just the ones on a unix box.
+ */
+export function readCurrentVersion(env) {
+    try {
+        const v = fs.readFileSync(pointerPath(env), 'utf8').trim();
+        return v || null;
+    }
+    catch {
+        return null;
+    }
+}
+export function readLocalBundle(env) {
+    const version = readCurrentVersion(env);
+    if (!version)
+        return null;
+    const dir = path.join(skillRoot(env), version);
+    let meta = {};
+    try {
+        meta = JSON.parse(fs.readFileSync(path.join(dir, 'bundle.json'), 'utf8'));
+    }
+    catch {
+        return null;
+    }
+    let files = [];
+    try {
+        files = fs.readdirSync(dir).filter((f) => f !== 'bundle.json');
+    }
+    catch {
+        return null;
+    }
+    return { version, dir, files, fetchedAt: meta.fetchedAt || '' };
+}
+/**
+ * Reverses the server's origin substitution so a downloaded document hashes to the value the
+ * manifest published.
+ *
+ * The manifest hashes the RAW template, before substitution, so that a bundle cached on one Sella
+ * domain is not invalidated by re-checking from another. What arrives over HTTP is the rendered
+ * form. Putting the placeholder back is exact rather than approximate because the server guarantees
+ * no template contains a literal absolute origin (asserted by findLiteralOrigins in the app), so
+ * every occurrence of the origin in a served document came from the placeholder.
+ */
+export function canonicalize(body, origin) {
+    const trimmed = origin.replace(/\/+$/, '');
+    return trimmed ? body.split(trimmed).join(ORIGIN_PLACEHOLDER) : body;
+}
+export function hashCanonical(body, origin) {
+    return `sha256:${crypto.createHash('sha256').update(canonicalize(body, origin), 'utf8').digest('hex')}`;
+}
+export async function fetchManifest(origin, fetchImpl = fetch) {
+    const base = origin.replace(/\/+$/, '');
+    const res = await fetchImpl(`${base}/skill.json`);
+    if (!res.ok)
+        throw new SkillSyncError(`Could not read ${base}/skill.json (HTTP ${res.status}).`);
+    const manifest = (await res.json());
+    if (!manifest?.version || !manifest?.files) {
+        throw new SkillSyncError(`${base}/skill.json is not a skill manifest.`);
+    }
+    return manifest;
+}
+/**
+ * Brings the local bundle to the version the server is serving.
+ *
+ * Unchanged files are copied forward from the previous bundle rather than re-downloaded, which is
+ * why the manifest carries a per-file hash at all. A version bump for a one-line prose fix then
+ * costs one small request instead of the whole bundle.
+ */
+export async function syncSkillBundle(opts) {
+    const { env, origin } = opts;
+    const fetchImpl = opts.fetchImpl || fetch;
+    const manifest = await fetchManifest(origin, fetchImpl);
+    const previousVersion = readCurrentVersion(env);
+    const dir = path.join(skillRoot(env), manifest.version);
+    const alreadyCurrent = previousVersion === manifest.version && fs.existsSync(dir);
+    if (alreadyCurrent && !opts.force) {
+        return {
+            version: manifest.version,
+            previousVersion,
+            dir,
+            written: [],
+            reused: Object.keys(manifest.files),
+            upToDate: true,
+        };
+    }
+    fs.mkdirSync(dir, { recursive: true });
+    const written = [];
+    const reused = [];
+    for (const [name, entry] of Object.entries(manifest.files)) {
+        const target = path.join(dir, name);
+        // Reuse an identical file from the previous bundle when the hash says it did not change.
+        if (!opts.force && previousVersion) {
+            const old = path.join(skillRoot(env), previousVersion, name);
+            try {
+                const body = fs.readFileSync(old, 'utf8');
+                if (hashCanonical(body, origin) === entry.sha256) {
+                    fs.writeFileSync(target, body);
+                    reused.push(name);
+                    continue;
+                }
+            }
+            catch {
+                // Not present or unreadable in the old bundle; fall through and download it.
+            }
+        }
+        const res = await fetchImpl(entry.url);
+        if (!res.ok)
+            throw new SkillSyncError(`Could not download ${name} (HTTP ${res.status}).`);
+        const body = await res.text();
+        // Integrity, not just freshness. A truncated or tampered document is worse than a stale one
+        // because it looks authoritative, so a mismatch fails the sync rather than being written.
+        const actual = hashCanonical(body, origin);
+        if (actual !== entry.sha256) {
+            throw new SkillSyncError(`${name} does not match the hash in the manifest. Expected ${entry.sha256}, got ${actual}. ` +
+                `Nothing was written. Retry, and if it persists report it rather than using the file.`);
+        }
+        fs.writeFileSync(target, body);
+        written.push(name);
+    }
+    fs.writeFileSync(path.join(dir, 'bundle.json'), JSON.stringify({ version: manifest.version, origin: origin.replace(/\/+$/, ''), fetchedAt: new Date().toISOString() }, null, 2) + '\n');
+    fs.mkdirSync(skillRoot(env), { recursive: true });
+    fs.writeFileSync(pointerPath(env), `${manifest.version}\n`);
+    return { version: manifest.version, previousVersion, dir, written, reused, upToDate: false };
+}
+function major(version) {
+    const m = /^(\d+)\.\d+\.\d+$/.exec(String(version || '').trim());
+    return m ? Number(m[1]) : null;
+}
+export async function skillStatus(env, origin, fetchImpl = fetch) {
+    const manifest = await fetchManifest(origin, fetchImpl);
+    const local = readLocalBundle(env);
+    const localMajor = major(local?.version || null);
+    const remoteMajor = major(manifest.version);
+    return {
+        localVersion: local?.version || null,
+        remoteVersion: manifest.version,
+        upToDate: Boolean(local && local.version === manifest.version),
+        breaking: localMajor !== null && remoteMajor !== null && localMajor < remoteMajor,
+        dir: local?.dir || null,
+        readFirst: manifest.readFirst || null,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sella-cli",
-  "version": "0.7.0",
+  "version": "0.9.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",
@@ -22,13 +22,26 @@
   ],
   "license": "MIT",
   "homepage": "https://sellag.vercel.app",
-  "bugs": { "url": "https://github.com/010100100100011101010100/ogsella/issues" },
-  "repository": { "type": "git", "url": "https://github.com/010100100100011101010100/ogsella", "directory": "cli" },
+  "bugs": {
+    "url": "https://github.com/010100100100011101010100/ogsella/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/010100100100011101010100/ogsella",
+    "directory": "cli"
+  },
   "type": "module",
-  "bin": { "sella": "./dist/index.js" },
+  "bin": {
+    "sella": "./dist/index.js"
+  },
   "main": "./dist/index.js",
-  "files": ["dist", "README.md"],
-  "engines": { "node": ">=18" },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "prepublishOnly": "npm run build",