sella-cli 0.6.5 → 0.7.0

package/README.md

@@ -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,8 @@ 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.
 - **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.
 
@@ -118,7 +119,7 @@ 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.
 
 ### Real-world: publish a CSV and get paid in USDC
 
@@ -177,6 +178,14 @@ SELLA_SETUP_CODE=SELLA-XXXX-XXXX-XXXX-XXXX npx sella-cli init --yes --json
 - You set the budget. You can revoke a key from the dashboard at any time.
 - Never paste API keys into URLs or shell history.
 
+## Telemetry (opt-in, off by default)
+
+The CLI can count which commands run and whether they exit cleanly, so we know what to fix first. Nothing is sent unless you say yes to the one-time question at the end of `sella init`, or you set `SELLA_TELEMETRY=1`.
+
+When enabled, each command sends one event: the command name (like `doctor`), the exit code, the CLI version, the OS name (like `darwin`), and a random install id. Never sent: search queries, emails, API keys, wallet addresses, file paths, or anything else you typed. Telemetry is always skipped in `--json`, `--yes`, and CI runs, and the send happens in a detached process, so it never delays a command.
+
+Opt out anytime with `SELLA_TELEMETRY=0` or by deleting `~/.sella/telemetry.json`.
+
 ## FAQ
 
 **Is this crypto hype?**
@@ -201,10 +210,11 @@ Sella has two other ways in: your agent can onboard itself over MCP with your em
 | 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? [Open an issue](https://github.com/010100100100011101010100/ogsella/issues). 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/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/index.js

@@ -11,8 +11,9 @@ 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.5';
+const VERSION = '0.7.0';
 function parseFlags(argv) {
     const flags = {
         json: false, yes: false, noColor: false, dryRun: false, noKeychain: false,
@@ -69,7 +70,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)
@@ -310,6 +311,16 @@ async function cmdInit(ctx, flags, printer) {
             { tag: 'free', text: `Test Sella without spending — ${rfi}?uc=zero-dollar-demo`, tone: 'dim' },
         ]);
         ui.detail(`Browse all ideas: ${rfi}`);
+        // One-time telemetry choice: only a human at a TTY is ever asked, and only once.
+        if (!flags.dryRun && shouldPromptTelemetry({ env: ctx.env, ioEnv: ctx.io.env, interactive: ui.interactive })) {
+            ui.bar();
+            const share = await ui.select('Help improve this CLI with anonymous usage stats?', [
+                { value: 'share', label: 'Share stats', hint: 'command name and pass or fail only, never your data or keys' },
+                { value: 'off', label: 'Keep it off', hint: 'nothing is sent' },
+            ]);
+            saveTelemetryDecision(ctx.env, share === 'share');
+            ui.detail(share === 'share' ? 'Thanks. Opt out anytime: SELLA_TELEMETRY=0' : 'Nothing will be sent. Opt in later: SELLA_TELEMETRY=1');
+        }
         const took = Math.max(1, Math.round((Date.now() - startedAt) / 1000));
         ui.outro(flags.dryRun ? 'Dry run complete — nothing was written.' : `Done in ${took}s — your agents can now buy on Sella.`);
     }
@@ -556,8 +567,17 @@ export async function runCli(argv, io = defaultIo(), env = defaultEnv()) {
 // Bin entry (skipped when imported by tests).
 const isMain = process.argv[1]?.endsWith('index.js') || process.argv[1]?.endsWith('sella');
 if (isMain) {
-    runCli(process.argv.slice(2))
-        .then((code) => process.exit(code))
+    const argv = process.argv.slice(2);
+    runCli(argv)
+        .then((code) => {
+        try {
+            recordCliEvent({ argv, exitCode: code, version: VERSION, env: defaultEnv(), ioEnv: process.env });
+        }
+        catch {
+            // Telemetry must never affect the exit path.
+        }
+        process.exit(code);
+    })
         .catch((err) => {
         console.error(err instanceof Error ? err.message : String(err));
         process.exit(1);

package/dist/telemetry-send.js

@@ -0,0 +1,18 @@
+// Detached one-shot telemetry sender: the CLI spawns this and exits immediately, so a slow or
+// dead network can never delay a command. argv carries no secrets (see telemetry.ts payload).
+const [, , url, body] = process.argv;
+if (url && body) {
+    try {
+        await fetch(url, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body,
+            signal: AbortSignal.timeout(4000),
+        });
+    }
+    catch {
+        // Best-effort by contract: there is nobody to report to.
+    }
+}
+process.exit(0);
+export {};

package/dist/telemetry.js

@@ -0,0 +1,153 @@
+import { spawn } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { randomUUID } from 'node:crypto';
+/** Mirrored by CLI_TELEMETRY_COMMANDS in lib/telemetry/cli-event.ts (server side). */
+export const TELEMETRY_COMMANDS = [
+    'none',
+    'init',
+    'pair',
+    'sandbox',
+    'clients',
+    'doctor',
+    'status',
+    'fund',
+    'mcp',
+    'publish',
+    'publish:init',
+    'publish:push',
+    'version',
+    'help',
+    'unknown',
+];
+const DEFAULT_ORIGIN = 'https://sellag.vercel.app';
+/** Flags whose next token is a value, not a command (mirrors parseFlags in index.ts). */
+const VALUE_FLAGS = new Set(['--client', '--clients', '--setup-code', '--email', '--card']);
+export function telemetryPath(env) {
+    return path.join(env.home, '.sella', 'telemetry.json');
+}
+export function loadTelemetryDecision(env) {
+    try {
+        const raw = JSON.parse(fs.readFileSync(telemetryPath(env), 'utf8'));
+        if (typeof raw.enabled !== 'boolean')
+            return null;
+        return {
+            enabled: raw.enabled,
+            installId: typeof raw.installId === 'string' && raw.installId ? raw.installId : 'unset',
+            decidedAt: typeof raw.decidedAt === 'string' ? raw.decidedAt : '',
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function saveTelemetryDecision(env, enabled) {
+    const file = telemetryPath(env);
+    const existing = loadTelemetryDecision(env);
+    const decision = {
+        enabled,
+        installId: existing?.installId && existing.installId !== 'unset' ? existing.installId : randomUUID(),
+        decidedAt: new Date().toISOString(),
+    };
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, `${JSON.stringify(decision, null, 2)}\n`);
+    return { ...decision, path: file };
+}
+/** SELLA_TELEMETRY=1 forces on, =0 forces off, anything else defers to the stored decision. */
+export function telemetryEnvOverride(ioEnv) {
+    const v = (ioEnv.SELLA_TELEMETRY || '').trim();
+    if (v === '1')
+        return true;
+    if (v === '0')
+        return false;
+    return null;
+}
+export function isCiRun(ioEnv) {
+    const v = (ioEnv.CI || '').trim().toLowerCase();
+    return v !== '' && v !== '0' && v !== 'false';
+}
+/** The single yes/no the sender consults. Defaults to off in every ambiguous case. */
+export function telemetryEnabled(env, ioEnv) {
+    if (isCiRun(ioEnv))
+        return false;
+    const override = telemetryEnvOverride(ioEnv);
+    if (override !== null)
+        return override;
+    return loadTelemetryDecision(env)?.enabled === true;
+}
+/** Ask only when a human is present, nothing decided yet, and no env var already speaks. */
+export function shouldPromptTelemetry(opts) {
+    if (!opts.interactive)
+        return false;
+    if (isCiRun(opts.ioEnv))
+        return false;
+    if (telemetryEnvOverride(opts.ioEnv) !== null)
+        return false;
+    return loadTelemetryDecision(opts.env) === null;
+}
+/** Collapse argv onto the fixed command vocabulary; free text can never pass through. */
+export function commandFromArgv(argv) {
+    if (argv.includes('--version') || argv.includes('-v'))
+        return 'version';
+    if (argv.includes('--help') || argv.includes('-h'))
+        return 'help';
+    const positional = [];
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (VALUE_FLAGS.has(arg)) {
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith('-'))
+            continue;
+        positional.push(arg);
+    }
+    const command = positional[0];
+    if (!command)
+        return 'none';
+    if (command === 'publish') {
+        const sub = positional[1];
+        if (sub === 'init')
+            return 'publish:init';
+        if (sub === 'push')
+            return 'publish:push';
+        return 'publish';
+    }
+    return TELEMETRY_COMMANDS.includes(command) && command !== 'unknown' && command !== 'none'
+        ? command
+        : 'unknown';
+}
+/**
+ * Fire one event for a finished command, if and only if the user opted in. Returns whether a
+ * send was attempted (for tests). Never throws; never delays the caller: the POST happens in a
+ * detached child that outlives this process.
+ */
+export function recordCliEvent(opts) {
+    try {
+        // Agent/automation modes carry no telemetry at all, even for opted-in installs.
+        if (opts.argv.includes('--json') || opts.argv.includes('--yes') || opts.argv.includes('-y'))
+            return false;
+        if (!telemetryEnabled(opts.env, opts.ioEnv))
+            return false;
+        const payload = {
+            installId: loadTelemetryDecision(opts.env)?.installId || 'unset',
+            command: commandFromArgv(opts.argv),
+            exitCode: Number.isInteger(opts.exitCode) ? opts.exitCode : 1,
+            version: opts.version,
+            platform: process.platform,
+        };
+        const origin = (opts.ioEnv.SELLA_MCP_URL || `${DEFAULT_ORIGIN}/api/mcp`).replace(/\/api\/mcp\/?$/, '') || DEFAULT_ORIGIN;
+        const sender = opts.senderPath || fileURLToPath(new URL('./telemetry-send.js', import.meta.url));
+        const spawnFn = opts.spawnFn || spawn;
+        const child = spawnFn(process.execPath, [sender, `${origin}/api/telemetry/cli`, JSON.stringify(payload)], {
+            detached: true,
+            stdio: 'ignore',
+        });
+        child.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sella-cli",
-  "version": "0.6.5",
+  "version": "0.7.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",