sella-cli 0.6.5 → 0.6.6

package/README.md

@@ -177,6 +177,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?**
@@ -204,7 +212,7 @@ Sella has two other ways in: your agent can onboard itself over MCP with your em
 
 ## 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? [Mail us](rasesh@buildifi.ai). We read every one.
 
 ## License
 

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.6.6';
 function parseFlags(argv) {
     const flags = {
         json: false, yes: false, noColor: false, dryRun: false, noKeychain: false,
@@ -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.6.6",
   "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",