sella-cli 0.5.0

package/dist/publish.js

@@ -0,0 +1,174 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+/**
+ * `sella publish` (CLI sprint C7): the supplier path no competitor CLI has — a CSV → live listing
+ * without opening the browser.
+ *
+ *   sella publish init <file.csv>   scaffold sella-dataset.json + a local structural pre-check
+ *   sella publish push [--card …]   upload via the SAME publish route the web dashboard uses
+ *
+ * The push authenticates with the machine's stored `sk_live_` key against POST /api/datasets
+ * (dual-auth per lib/withPublisherAuth.ts), so the CLI and dashboard supplier flows share one core.
+ * Zero runtime deps: the pre-check is a light structural preview (not the server-side ADC run) so a
+ * publisher sees obvious problems — ragged rows, empty columns — before spending a round-trip.
+ */
+export const CARD_FILENAME = 'sella-dataset.json';
+/**
+ * Light, dependency-free structural preview of a CSV. NOT the server-side ADC evaluation — it just
+ * surfaces obvious problems (no rows, ragged rows, duplicate/blank headers, empty columns) so the
+ * publisher can fix them before pushing. Naive comma-split: quoted commas aren't parsed, which is
+ * fine for a heads-up preview.
+ */
+export function precheckCsv(text) {
+    const warnings = [];
+    const lines = text.split(/\r?\n/).filter((l) => l.length > 0);
+    if (lines.length === 0) {
+        return { columns: [], rows: 0, warnings: ['File is empty.'], emptyCells: 0 };
+    }
+    const columns = lines[0].split(',').map((c) => c.trim());
+    if (columns.some((c) => c === ''))
+        warnings.push('One or more header cells are blank.');
+    const dupes = columns.filter((c, i) => c !== '' && columns.indexOf(c) !== i);
+    if (dupes.length)
+        warnings.push(`Duplicate header(s): ${[...new Set(dupes)].join(', ')}.`);
+    const dataLines = lines.slice(1);
+    if (dataLines.length === 0)
+        warnings.push('No data rows — only a header was found.');
+    let emptyCells = 0;
+    let ragged = 0;
+    const nonEmptyPerColumn = new Array(columns.length).fill(0);
+    for (const line of dataLines) {
+        const cells = line.split(',');
+        if (cells.length !== columns.length)
+            ragged += 1;
+        for (let i = 0; i < columns.length; i += 1) {
+            const v = (cells[i] ?? '').trim();
+            if (v === '')
+                emptyCells += 1;
+            else
+                nonEmptyPerColumn[i] += 1;
+        }
+    }
+    if (ragged)
+        warnings.push(`${ragged} row(s) have a different column count than the header.`);
+    const emptyColumns = columns.filter((_, i) => dataLines.length > 0 && nonEmptyPerColumn[i] === 0);
+    if (emptyColumns.length)
+        warnings.push(`Column(s) with no values: ${emptyColumns.join(', ')}.`);
+    return { columns, rows: dataLines.length, emptyCells, warnings };
+}
+function titleFromFilename(csvPath) {
+    const base = path.basename(csvPath).replace(/\.[^.]+$/, '');
+    const words = base.replace(/[_-]+/g, ' ').replace(/\s+/g, ' ').trim();
+    return words ? words.replace(/\b\w/g, (c) => c.toUpperCase()).slice(0, 100) : 'Untitled dataset';
+}
+/**
+ * Scaffold a dataset card next to the CSV and run the pre-check. Does NOT overwrite an existing
+ * card (wroteNew=false) so re-running `init` is safe. Throws only if the CSV can't be read.
+ */
+export function scaffoldCard(csvPath) {
+    const text = fs.readFileSync(csvPath, 'utf8'); // throws a clear ENOENT the caller surfaces
+    const precheck = precheckCsv(text);
+    const cardPath = path.join(path.dirname(path.resolve(csvPath)), CARD_FILENAME);
+    const card = {
+        $schema: 'sella-dataset/v1',
+        title: titleFromFilename(csvPath),
+        description: '',
+        category: 'Other',
+        tags: [],
+        tier: 'standard',
+        priceUSDC: 0,
+        format: 'csv',
+        licenseType: 'cc-by-4.0',
+        csv: path.basename(csvPath),
+    };
+    if (fs.existsSync(cardPath)) {
+        return { cardPath, card: JSON.parse(fs.readFileSync(cardPath, 'utf8')), precheck, wroteNew: false };
+    }
+    fs.writeFileSync(cardPath, JSON.stringify(card, null, 2) + '\n');
+    return { cardPath, card, precheck, wroteNew: true };
+}
+const REQUIRED_CARD_FIELDS = ['title', 'description', 'category', 'tier', 'format', 'licenseType', 'csv'];
+const TERMINAL_STATUSES = new Set(['live', 'manual_review']);
+/** Read the card + its CSV, create the dataset via the shared publish route, and poll for status. */
+export async function pushDataset(opts) {
+    const fetchImpl = opts.fetchImpl || fetch;
+    const sleep = opts.sleep || ((ms) => new Promise((r) => setTimeout(r, ms)));
+    const maxPolls = opts.maxPolls ?? 6;
+    const pollIntervalMs = opts.pollIntervalMs ?? 1500;
+    let card;
+    try {
+        card = JSON.parse(fs.readFileSync(opts.cardPath, 'utf8'));
+    }
+    catch {
+        return { ok: false, error: `Could not read the dataset card at ${opts.cardPath}. Run \`sella publish init <file.csv>\` first.` };
+    }
+    const missing = REQUIRED_CARD_FIELDS.filter((f) => card[f] === undefined || card[f] === '' || card[f] === null);
+    if (missing.length) {
+        return { ok: false, error: `Card is missing required field(s): ${missing.join(', ')}. Edit ${path.basename(opts.cardPath)} and retry.` };
+    }
+    if (!card.description || String(card.description).trim() === '') {
+        return { ok: false, error: `Add a "description" to ${path.basename(opts.cardPath)} before publishing.` };
+    }
+    const csvPath = path.isAbsolute(card.csv) ? card.csv : path.join(path.dirname(opts.cardPath), card.csv);
+    let content;
+    try {
+        content = fs.readFileSync(csvPath, 'utf8');
+    }
+    catch {
+        return { ok: false, error: `Could not read the CSV referenced by the card: ${csvPath}` };
+    }
+    const body = {
+        title: card.title,
+        description: card.description,
+        category: card.category,
+        tags: Array.isArray(card.tags) ? card.tags : [],
+        tier: card.tier,
+        priceUSDC: typeof card.priceUSDC === 'number' ? card.priceUSDC : Number(card.priceUSDC ?? 0),
+        format: card.format,
+        licenseType: card.licenseType,
+        ...(card.licenseDetails ? { licenseDetails: card.licenseDetails } : {}),
+        content,
+    };
+    let created;
+    try {
+        const res = await fetchImpl(`${opts.origin}/api/datasets`, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json', authorization: `Bearer ${opts.apiKey}` },
+            body: JSON.stringify(body),
+        });
+        const json = await res.json().catch(() => ({}));
+        if (res.status === 401)
+            return { ok: false, error: 'Not authenticated — run `sella pair` to (re)authenticate this machine.' };
+        if (res.status === 422)
+            return { ok: false, error: 'The listing was rejected by validation.', fieldErrors: json.fieldErrors };
+        if (!res.ok)
+            return { ok: false, error: `Publish endpoint responded ${res.status}.` };
+        created = json.dataset;
+    }
+    catch (err) {
+        return { ok: false, error: `Could not reach ${opts.origin}: ${err instanceof Error ? err.message : 'network error'}` };
+    }
+    const datasetId = created?.id ? String(created.id) : undefined;
+    if (!datasetId)
+        return { ok: false, error: 'The server accepted the upload but returned no dataset id.' };
+    const listingUrl = `${opts.origin}/datasets/${datasetId}`;
+    // Creation kicks off async scoring (processing → manual_review | live). Poll a bounded number of
+    // times; report the current status either way so a headless run never hangs.
+    let status = String(created.publishStatus || 'processing');
+    for (let i = 0; i < maxPolls && !TERMINAL_STATUSES.has(status); i += 1) {
+        await sleep(pollIntervalMs);
+        try {
+            const res = await fetchImpl(`${opts.origin}/api/datasets/${encodeURIComponent(datasetId)}/publish-status`, {
+                headers: { authorization: `Bearer ${opts.apiKey}` },
+            });
+            if (res.ok) {
+                const json = await res.json().catch(() => ({}));
+                status = String(json.dataset?.publishStatus || status);
+            }
+        }
+        catch {
+            break; // network blip — stop polling, report what we have
+        }
+    }
+    return { ok: true, datasetId, status, listingUrl };
+}

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "sella-cli",
+  "version": "0.5.0",
+  "description": "Sella onboarding CLI — install Sella into your agent clients, pair, verify, fund, publish. (`npx sella-cli init`)",
+  "license": "MIT",
+  "homepage": "https://sella.network",
+  "repository": { "type": "git", "url": "https://github.com/010100100100011101010100/ogsella", "directory": "cli" },
+  "type": "module",
+  "bin": { "sella": "./dist/index.js" },
+  "main": "./dist/index.js",
+  "files": ["dist", "README.md"],
+  "engines": { "node": ">=18" },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "typescript": "^5"
+  }
+}