@prave/cli 1.4.7 → 1.4.8

package/dist/commands/import.js

@@ -123,17 +123,17 @@ export async function importCommand(opts) {
     const me = await fetchMyPlan();
     if (!me.limits.can_authoring_public && !me.limits.can_authoring_private) {
         log.warn('Uploading Skills requires the Pro plan or higher.');
-        log.dim(formatUpgradeHint('explorer'));
+        log.dim(formatUpgradeHint('pro'));
         return;
     }
     if (visibility === 'private' && !me.limits.can_authoring_private) {
         log.warn('Private uploads require the Pro plan.');
-        log.dim(formatUpgradeHint('explorer'));
+        log.dim(formatUpgradeHint('pro'));
         return;
     }
     if (visibility === 'public' && !me.limits.can_authoring_public) {
         log.warn('Public uploads require the Pro plan.');
-        log.dim(formatUpgradeHint('explorer'));
+        log.dim(formatUpgradeHint('pro'));
         return;
     }
     // Clamp the queue to the caller's authoring ceiling. `null` = unlimited
@@ -142,7 +142,7 @@ export async function importCommand(opts) {
     if (me.limits.authoring_max_skills !== null &&
         queue.length > me.limits.authoring_max_skills) {
         log.warn(`Your ${me.limits.label} plan caps authored Skills at ${me.limits.authoring_max_skills}. Trimming queue from ${queue.length} → ${me.limits.authoring_max_skills}.`);
-        log.dim(formatUpgradeHint('explorer'));
+        log.dim(formatUpgradeHint('pro'));
         queue = queue.slice(0, me.limits.authoring_max_skills);
     }
     const uploadSpinner = ora(`Uploading ${queue.length} skills as ${visibility}…`).start();
@@ -191,7 +191,7 @@ export async function importCommand(opts) {
         .join(' · ');
     uploadSpinner.succeed(tail);
     if (gated > 0)
-        log.dim(formatUpgradeHint('explorer'));
+        log.dim(formatUpgradeHint('pro'));
     // Always analyze after upload — best effort, never blocks the user.
     const analyzeSpinner = ora(`Analyzing ${queue.length} skills…`).start();
     for (const s of queue) {

package/dist/commands/install.js

@@ -1,12 +1,12 @@
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { createInterface } from 'node:readline/promises';
 import chalk from 'chalk';
 import ora from 'ora';
 import { track } from '../lib/analytics.js';
 import { api, ApiError } from '../lib/api.js';
 import { CONFIG } from '../lib/config.js';
 import { loadCredentials, requireAuth } from '../lib/credentials.js';
+import { nudgeAfter } from '../lib/nudge.js';
 import { fetchMyPlan, formatUpgradeHint } from '../lib/plan.js';
 import { assertSlug, InvalidSlugError } from '../lib/slug.js';
 import { log } from '../utils/logger.js';
@@ -51,7 +51,7 @@ export async function installCommand(slug, opts = {}) {
             const remaining = data.installs.remaining;
             if (remaining !== null && remaining <= 0) {
                 log.warn(`Your ${me.limits.label} plan caps installs at ${me.limits.install_monthly_limit}/month. You've used all of them.`);
-                log.dim(formatUpgradeHint('explorer'));
+                log.dim(formatUpgradeHint('pro'));
                 process.exitCode = 1;
                 return;
             }
@@ -102,22 +102,13 @@ export async function installCommand(slug, opts = {}) {
             /* file unreadable — skip */
         }
     }
-    // Offer to deploy to all configured agents — unless the caller already
-    // answered the question (e.g. `prave sync` collects the answer once for
-    // the whole batch and threads it through `skipDeployPrompt`).
-    if (opts.skipDeployPrompt)
-        return;
-    const rl = createInterface({ input: process.stdin, output: process.stdout });
-    try {
-        const ans = (await rl.question('\nDeploy to all configured agents? [y/N] ')).trim().toLowerCase();
-        if (ans === 'y' || ans === 'yes') {
-            const { deployCommand } = await import('./deploy.js');
-            await deployCommand(slug, {});
-        }
-    }
-    finally {
-        rl.close();
-    }
+    // `prave deploy` was retired — install fans out to the user's
+    // configured agent targets directly (see multi_agent_targets in
+    // PLAN_LIMITS), so no follow-up prompt is needed.
+    // Defensive: requireAuth above already blocks unauth callers, so this
+    // is a no-op today. Keeps the nudge consistent if install ever opens
+    // to anonymous use (it's safe — `nudgeAfter` self-gates on auth).
+    await nudgeAfter('install');
 }
 async function pullOne(slug, ctx) {
     const { data: skill } = await api.get(`/api/v1/skills/${encodeURIComponent(slug)}`, ctx.hasSession);

package/dist/commands/list.js

@@ -5,7 +5,7 @@ import { tokenTier } from '@prave/shared';
 import { track } from '../lib/analytics.js';
 import { api } from '../lib/api.js';
 import { CONFIG } from '../lib/config.js';
-import { nudgeIfAnonymous } from '../lib/nudge.js';
+import { nudgeAfter } from '../lib/nudge.js';
 import { log } from '../utils/logger.js';
 const TIER_EMOJI = {
     lean: '🟢',
@@ -69,7 +69,7 @@ export async function listCommand(opts = {}) {
             console.log(`  ${chalk.cyan('•')} ${name}`);
         }
         log.dim(`\n${localSlugs.length} local skill${localSlugs.length === 1 ? '' : 's'} in ${CONFIG.skillsDir}`);
-        await nudgeIfAnonymous('list');
+        await nudgeAfter('list');
         return;
     }
     // Enriched path — pull intelligence and merge by slug (best-effort).

package/dist/commands/login.js

@@ -39,6 +39,7 @@ export async function loginCommand() {
                 expires_at: data.expires_at ?? undefined,
             });
             spinner.succeed('Logged in.');
+            log.dim("Nudges disabled — you're all set.");
             // Replay any Skill-invocation events the hook buffered while the
             // user was offline / signed out. Silent when nothing's queued;
             // prints "Syncing N events…" + a confirmation when the file has

package/dist/commands/overview.js

@@ -3,6 +3,7 @@ import ora from 'ora';
 import { track } from '../lib/analytics.js';
 import { api, ApiError } from '../lib/api.js';
 import { requireAuth } from '../lib/credentials.js';
+import { nudgeAfter } from '../lib/nudge.js';
 import { log } from '../utils/logger.js';
 function formatThousands(n) {
     if (n < 1000)
@@ -71,5 +72,9 @@ export async function overviewCommand(opts = {}) {
         spinner.stop();
         log.error(err instanceof ApiError ? err.message : err.message);
         process.exitCode = 1;
+        return;
     }
+    // No-op for signed-in users (overview requires auth), but harmless and
+    // future-proof if we ever expose a public overview-equivalent.
+    await nudgeAfter('overview');
 }

package/dist/commands/search.js

@@ -1,7 +1,7 @@
 import chalk from 'chalk';
 import { track } from '../lib/analytics.js';
 import { api } from '../lib/api.js';
-import { nudgeIfAnonymous } from '../lib/nudge.js';
+import { nudgeAfter } from '../lib/nudge.js';
 import { log } from '../utils/logger.js';
 const SLUG_COL = 32;
 function formatInstalls(n) {
@@ -42,5 +42,5 @@ export async function searchCommand(query) {
     if (skills.length > 0) {
         console.log(chalk.dim('  → prave install <slug>'));
     }
-    await nudgeIfAnonymous('search');
+    await nudgeAfter('search');
 }

package/dist/commands/sync.js

@@ -72,11 +72,11 @@ export async function syncCommand() {
     const session = await requireAuth('prave sync');
     if (!session)
         return;
-    // Plan gate: sync requires Explorer or higher.
+    // Plan gate: sync requires Pro or higher.
     const me = await fetchMyPlan();
     if (!me.limits.can_cli_sync) {
-        log.warn('Sync requires the Explorer plan or higher.');
-        log.dim(formatUpgradeHint('explorer'));
+        log.warn('Sync requires the Pro plan or higher.');
+        log.dim(formatUpgradeHint('pro'));
         return;
     }
     // Last-sync nudge. We read state up-front because if the user bails on
@@ -134,19 +134,10 @@ export async function syncCommand() {
     // Pre-flight time estimate — sets expectations before the user hits Y.
     const estSeconds = estimateSeconds(slugs.length);
     console.log(chalk.dim(`Syncing ${slugs.length} Skill${slugs.length === 1 ? '' : 's'} — this takes about ${estSeconds} seconds.`));
-    // Ask the deploy question ONCE for the whole batch.
-    const rl = createInterface({ input: process.stdin, output: process.stdout });
-    let deployAfter = false;
-    try {
-        const ans = (await rl.question(`\nAfter syncing, deploy all ${slugs.length} Skills to your configured agents? [y/N] `))
-            .trim()
-            .toLowerCase();
-        deployAfter = ans === 'y' || ans === 'yes';
-    }
-    finally {
-        rl.close();
-    }
-    // Parallel install with live progress counter.
+    // Parallel install with live progress counter. The legacy post-sync
+    // "deploy to all agents?" prompt is gone — `prave deploy` has been
+    // retired and `installCommand` already fans out to the user's
+    // configured agent targets directly.
     const progress = ora(`Installed 0 / ${slugs.length}`).start();
     let done = 0;
     let updated = 0;
@@ -174,18 +165,6 @@ export async function syncCommand() {
     // *did* attempt a sync, and we want the cooldown to apply to retries
     // just as much as to the happy path.
     await writeState({ last_sync_at: new Date().toISOString() }).catch(() => { });
-    if (deployAfter && updated > 0) {
-        const { deployCommand } = await import('./deploy.js');
-        log.info(`\nDeploying ${updated} Skills to configured agents…`);
-        for (const slug of slugs) {
-            try {
-                await deployCommand(slug, {});
-            }
-            catch (err) {
-                log.warn(`  ✗ deploy ${slug} — ${err.message}`);
-            }
-        }
-    }
     // Tail end of sync: fire a quiet usage scan so the optimiser stays warm
     // without the user having to remember an extra command. Quiet mode means
     // we only log a one-liner ("Usage: 12 new, 88 known.") instead of taking

package/dist/commands/update.js

@@ -30,7 +30,7 @@ export async function updateCommand(slug, opts = {}) {
     const me = await fetchMyPlan();
     if (!me.limits.can_cli_update) {
         log.warn(`\`prave update\` requires the Pro plan or higher.`);
-        log.dim(formatUpgradeHint('explorer'));
+        log.dim(formatUpgradeHint('pro'));
         process.exitCode = 1;
         return;
     }

package/dist/commands/whatdoes.js

@@ -3,7 +3,7 @@ import ora from 'ora';
 import { tokenTier } from '@prave/shared';
 import { track } from '../lib/analytics.js';
 import { api, ApiError } from '../lib/api.js';
-import { nudgeIfAnonymous } from '../lib/nudge.js';
+import { nudgeAfter } from '../lib/nudge.js';
 import { log } from '../utils/logger.js';
 const TIER_BADGE = {
     lean: chalk.green('🟢 Lean'),
@@ -72,7 +72,7 @@ export async function whatdoesCommand(skillName) {
         console.log(`🔗 Requires:      ${requires}`);
         console.log(`${data.conflicts.length > 0 ? chalk.yellow('⚠️ ') : '⚠️ '}Conflicts:     ${conflicts}`);
         console.log(chalk.dim(RULE));
-        await nudgeIfAnonymous('whatdoes');
+        await nudgeAfter('whatdoes');
     }
     catch (err) {
         spinner.stop();

package/dist/commands/whoami.js

@@ -11,7 +11,7 @@ import { log } from '../utils/logger.js';
  * is the only thing that ever surfaces in UI / CLI copy.
  */
 function planDisplay(plan) {
-    if (plan === 'free' || plan === 'explorer' || plan === 'creator') {
+    if (plan === 'free' || plan === 'pro' || plan === 'max') {
         return planLabel(plan);
     }
     return plan;

package/dist/index.js

@@ -24,6 +24,7 @@ import { usageHookInstallCommand, usageHookUninstallCommand, usageReportCommand,
 import { whatdoesCommand } from './commands/whatdoes.js';
 import { whoamiCommand } from './commands/whoami.js';
 import { initAnalytics } from './lib/analytics.js';
+import { nudgeFirstRun } from './lib/nudge.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(resolve(__dirname, '..', 'package.json'), 'utf8'));
 initAnalytics(pkg.version);
@@ -203,6 +204,19 @@ program
         'Docs:   https://prave.app/docs',
     ].join('\n'));
 });
+// Global first-run banner. Fires once on the user's very first command
+// regardless of which one it was — catches commands that don't have a
+// per-action nudge wired in (e.g. `prave docs`, `prave conflicts`).
+// Per-command `nudgeAfter` calls also invoke `nudgeFirstRun` first, so
+// the once-per-process guard inside the nudge module prevents doubling.
+program.hook('postAction', async () => {
+    try {
+        await nudgeFirstRun();
+    }
+    catch {
+        /* nudges are decorative — never block on them */
+    }
+});
 program.parseAsync().catch((err) => {
     console.error(err.message);
     process.exit(1);

package/dist/lib/nudge-constants.js

@@ -0,0 +1,88 @@
+/**
+ * Centralized copy for every CLI conversion nudge.
+ *
+ * Tuning the funnel = editing this file. The renderer in nudge.ts is dumb
+ * and the wiring in command files is dumb; all the messaging lives here so
+ * a product person can reword without grokking node/chalk.
+ *
+ * Soft nudges = single short pitch under the command output. Strong nudges
+ * = double-line banner with a bulleted value-prop list. Use strong for
+ * commands where the gap between "what they just got locally" and "what
+ * they'd get signed-in" is biggest (overview/whatdoes/first-run).
+ */
+/* --------------------------------------------------------------------- */
+/*  Soft nudges (Nudge 1–4) — throttled to ~1 in every 3 commands.         */
+/* --------------------------------------------------------------------- */
+export const NUDGE_GENERIC = {
+    kind: 'soft',
+    icon: '💡',
+    title: 'Sign in to unlock the full Prave experience',
+    cta: 'prave.app/signup  ·  takes 10 seconds',
+};
+export const NUDGE_LIST = {
+    kind: 'soft',
+    icon: '🔍',
+    title: 'Want AI-generated descriptions for each Skill?',
+    cta: 'Sign in free at prave.app — no credit card needed.',
+};
+export const NUDGE_SEARCH = {
+    kind: 'soft',
+    icon: '🚀',
+    title: 'Unlock semantic search and find Skills by intent.',
+    cta: 'Upgrade to Pro at prave.app — $12/mo',
+};
+export const NUDGE_INSTALL = {
+    kind: 'soft',
+    icon: '📊',
+    title: 'Track token costs and usage for this Skill at prave.app',
+    cta: 'Free account · takes 10 seconds · no credit card',
+};
+/* --------------------------------------------------------------------- */
+/*  Strong nudges (Nudge 5–6) — always shown to unauthenticated users.     */
+/* --------------------------------------------------------------------- */
+export const NUDGE_DEEP = {
+    kind: 'strong',
+    icon: '✨',
+    title: "You're one step away from the full picture.",
+    bullets: [
+        'AI-generated descriptions for all your Skills',
+        'Conflict detection across your library',
+        '30-day usage history from PostToolUse hook',
+        'Cross-machine sync',
+    ],
+    cta: 'prave.app/signup  ·  free forever  ·  10 seconds',
+};
+export const NUDGE_FIRST_RUN = {
+    kind: 'strong',
+    icon: '👋',
+    title: "Welcome to Prave! You're running the CLI — nice.",
+    bullets: [
+        '4,300+ developers are already using it',
+        'Discover 1,200+ Skills with semantic search',
+        'Audit your token footprint',
+        'Sync across all your machines',
+    ],
+    cta: 'prave login      ← connect CLI to your account',
+    ctaSecondary: 'prave.app/signup ← create free account first',
+};
+/** Picks the right variant for a given context. */
+export function nudgeFor(context) {
+    switch (context) {
+        case 'list':
+            return NUDGE_LIST;
+        case 'search':
+            return NUDGE_SEARCH;
+        case 'install':
+            return NUDGE_INSTALL;
+        case 'whatdoes':
+        case 'overview':
+            return NUDGE_DEEP;
+        case 'generic':
+        default:
+            return NUDGE_GENERIC;
+    }
+}
+/** True for nudges that bypass the 1-in-3 throttle. */
+export function isAlwaysShow(context) {
+    return context === 'whatdoes' || context === 'overview';
+}

package/dist/lib/nudge.js

@@ -1,48 +1,157 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import chalk from 'chalk';
+import { CONFIG } from './config.js';
 import { loadCredentials } from './credentials.js';
+import { isAlwaysShow, NUDGE_FIRST_RUN, nudgeFor, } from './nudge-constants.js';
 let alreadyNudged = false;
-export async function nudgeIfAnonymous(context = 'generic') {
+/* --------------------------------------------------------------------- */
+/*  Auth + state helpers                                                  */
+/* --------------------------------------------------------------------- */
+export async function isAuthenticated() {
+    const creds = await loadCredentials();
+    if (!creds?.access_token)
+        return false;
+    // expires_at is unix-seconds. If absent (pre-refresh-token creds) we
+    // assume valid — the API call itself will 401 and trigger re-login.
+    if (typeof creds.expires_at === 'number' && creds.expires_at < Math.floor(Date.now() / 1000)) {
+        return false;
+    }
+    return true;
+}
+async function readConfig() {
+    try {
+        const raw = await readFile(CONFIG.configPath, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === 'object')
+            return parsed;
+        return {};
+    }
+    catch {
+        return {};
+    }
+}
+async function writeConfigPatch(patch) {
+    const existing = await readConfig();
+    const next = { ...existing, ...patch };
+    await mkdir(CONFIG.praveDir, { recursive: true, mode: 0o700 });
+    await writeFile(CONFIG.configPath, JSON.stringify(next, null, 2), 'utf8');
+}
+/**
+ * Counter-based throttle for soft nudges. Reads the current count,
+ * increments, persists, and returns true when (count % 3 === 0) — so
+ * roughly every third invocation. The first invocation returns false:
+ * we'd rather skip than be loud on the user's first real command.
+ */
+export async function shouldShowNudge() {
+    const cfg = await readConfig();
+    const current = typeof cfg.nudge_count === 'number' ? cfg.nudge_count : 0;
+    const next = current + 1;
+    await writeConfigPatch({ nudge_count: next });
+    return next % 3 === 0;
+}
+/* --------------------------------------------------------------------- */
+/*  Renderer                                                              */
+/* --------------------------------------------------------------------- */
+function makeRule(char, width = 60) {
+    return char.repeat(width);
+}
+function renderSoft(n) {
+    const rule = chalk.dim(makeRule('─'));
+    const title = chalk.dim(`${n.icon}  ${n.title}`);
+    const cta = chalk.dim(`   ${n.cta}`);
+    return [rule, title, cta, rule].join('\n');
+}
+function renderStrong(n) {
+    const rule = chalk.cyan(makeRule('═'));
+    const title = chalk.bold(`${n.icon}  ${n.title}`);
+    const bullets = n.bullets.map((b) => chalk.dim(`   → ${b}`)).join('\n');
+    const cta = chalk.cyan(`   ${n.cta}`);
+    const cta2 = n.ctaSecondary ? '\n' + chalk.cyan(`   ${n.ctaSecondary}`) : '';
+    return [rule, title, '', bullets, '', cta + cta2, rule].join('\n');
+}
+export function showNudge(nudge) {
+    console.log();
+    console.log(nudge.kind === 'strong' ? renderStrong(nudge) : renderSoft(nudge));
+}
+/* --------------------------------------------------------------------- */
+/*  Public entry points                                                   */
+/* --------------------------------------------------------------------- */
+/**
+ * Gate that all nudge entry points share. Skips when:
+ *   - user is signed in
+ *   - we've already nudged in this process
+ *   - stdout isn't a TTY (pipes, CI)
+ *   - PRAVE_QUIET=1 or PRAVE_TELEMETRY=0 is set
+ */
+async function canNudge() {
     if (alreadyNudged)
-        return;
+        return false;
+    if (!process.stdout.isTTY)
+        return false;
     if (process.env.PRAVE_QUIET === '1')
-        return;
+        return false;
     if (process.env.PRAVE_TELEMETRY === '0')
-        return; // user opted out of analytics
-    // CI / non-interactive shells are unlikely to act on a nudge — and
-    // the noise breaks pipe-parsing scripts.
-    if (!process.stdout.isTTY)
+        return false;
+    if (await isAuthenticated())
+        return false;
+    return true;
+}
+/**
+ * Show the first-run welcome banner if it's the user's very first command
+ * (no nudge_count yet AND first_run not yet set to false). Always strong,
+ * always bypasses the throttle.
+ *
+ * Returns true when shown — call sites use this to skip the regular nudge
+ * on the same turn so we don't double-print.
+ */
+export async function nudgeFirstRun() {
+    if (!(await canNudge()))
+        return false;
+    const cfg = await readConfig();
+    // first_run defaults to "yes, show it" unless we've already flipped
+    // the flag. A missing config file → first run.
+    const alreadyShown = cfg.first_run === false;
+    if (alreadyShown)
+        return false;
+    alreadyNudged = true;
+    showNudge(NUDGE_FIRST_RUN);
+    await writeConfigPatch({ first_run: false });
+    return true;
+}
+/**
+ * Main per-command nudge entry. Pick the most specific context — the
+ * renderer maps it to the matching constant. Strong contexts
+ * (overview/whatdoes) always show; soft ones go through the 1-in-3
+ * throttle.
+ */
+export async function nudgeAfter(context = 'generic') {
+    // First-run handling lives here so every command path picks it up
+    // without needing its own boilerplate. If we showed the welcome banner,
+    // skip the regular nudge for this turn — too noisy otherwise.
+    const showedFirstRun = await nudgeFirstRun();
+    if (showedFirstRun)
+        return;
+    if (!(await canNudge()))
+        return;
+    if (isAlwaysShow(context)) {
+        alreadyNudged = true;
+        showNudge(nudgeFor(context));
+        return;
+    }
+    if (!(await shouldShowNudge()))
         return;
-    const creds = await loadCredentials();
-    if (creds)
-        return; // logged-in → no nudge
     alreadyNudged = true;
-    const cta = chalk.cyan('prave login');
-    const url = chalk.dim('— takes 10 seconds, free forever');
-    const message = (() => {
-        switch (context) {
-            case 'search':
-                return `${chalk.dim('Save these to your library, get token costs + conflicts.')}\n${chalk.dim('→')} ${cta} ${url}`;
-            case 'whatdoes':
-                return `${chalk.dim('Want the full audit — triggers, conflicts, token cost?')}\n${chalk.dim('→')} ${cta} ${url}`;
-            case 'list':
-                return `${chalk.dim('Sign in to see AI descriptions, conflicts and token cost.')}\n${chalk.dim('→')} ${cta} ${url}`;
-            case 'overview':
-                return `${chalk.dim('Track this over time on prave.app.')}\n${chalk.dim('→')} ${cta} ${url}`;
-            case 'generic':
-            default:
-                return `${chalk.dim('Get the full Skill Intelligence on prave.app.')}\n${chalk.dim('→')} ${cta} ${url}`;
-        }
-    })();
-    // One blank line so the nudge isn't glued to the command's main
-    // output. Two `console.log` calls so the chalk styles survive the
-    // pipeline cleanly.
-    console.log();
-    console.log(message);
+    showNudge(nudgeFor(context));
 }
+/**
+ * Back-compat alias. Older call sites used this name; new code should
+ * call `nudgeAfter` directly.
+ */
+export const nudgeIfAnonymous = nudgeAfter;
 /**
  * Post-install banner used by package.json's `postinstall` script.
- * Runs once after `npm i -g @prave/cli`. Stays short — npm's install
- * log is already crowded.
+ * Runs once after `npm i -g @prave/cli`. Kept short — npm's install log
+ * is already crowded.
  */
 export function printPostInstallBanner() {
     if (process.env.CI)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prave/cli",
-  "version": "1.4.7",
+  "version": "1.4.8",
   "description": "Prave CLI — discover, install, version, test, and ship Claude Skills. The developer platform for the complete Skill lifecycle.",
   "type": "module",
   "keywords": [
@@ -54,7 +54,7 @@
     "ora": "^8.0.1",
     "tar": "^7.4.3",
     "undici": "^6.18.0",
-    "@prave/shared": "1.4.7"
+    "@prave/shared": "1.4.8"
   },
   "devDependencies": {
     "@types/node": "^20.12.7",

package/dist/commands/deploy.js

@@ -1,189 +0,0 @@
-/**
- * Multi-agent fan-out helper.
- *
- * This module used to back a public `prave deploy <skill>` command, but
- * shipping that as a top-level CLI surface only duplicated what
- * `prave install` already prompts for ("Deploy to all configured agents?
- * [y/N]"). The standalone command was removed; `deployCommand` lives on
- * as an internal helper that `install.ts` and `sync.ts` import to do
- * the actual fan-out + Cursor `.mdc` rewrite.
- */
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import chalk from 'chalk';
-import ora from 'ora';
-import { AGENT_REGISTRY, compileSkill } from '@prave/shared';
-import { track } from '../lib/analytics.js';
-import { api, ApiError } from '../lib/api.js';
-import { requireAuth } from '../lib/credentials.js';
-import { fetchMyPlan, formatUpgradeHint } from '../lib/plan.js';
-import { CONFIG } from '../lib/config.js';
-import { assertSlug, InvalidSlugError } from '../lib/slug.js';
-import { log } from '../utils/logger.js';
-function detectOsKey(detected) {
-    if (detected === 'windows')
-        return 'windows';
-    // mac + linux both use POSIX paths under "mac" in the registry.
-    return 'mac';
-}
-function expandHome(p, os) {
-    if (os === 'windows')
-        return p;
-    if (p.startsWith('~')) {
-        return join(homedir(), p.slice(1).replace(/^[\\/]/, ''));
-    }
-    return p;
-}
-async function readLocalSkill(slug) {
-    const path = join(CONFIG.skillsDir, slug, 'SKILL.md');
-    try {
-        return await readFile(path, 'utf8');
-    }
-    catch {
-        return null;
-    }
-}
-async function fetchRemoteSkill(slug) {
-    const { data } = await api.get(`/api/v1/skills/${encodeURIComponent(slug)}`, true);
-    if (!data.content) {
-        throw new ApiError(`Remote skill "${slug}" has no content.`, 404);
-    }
-    return data.content;
-}
-/**
- * Build the on-disk write path for the given agent + slug. The
- * `compileSkill()` import from `@prave/shared` decides the *content*
- * transform (e.g. Cursor `.mdc` frontmatter rewrite); this function
- * only resolves the absolute filesystem location by combining the
- * agent's `basePath` from user settings with the relative path the
- * shared compiler returned.
- */
-function buildDestPath(agent, basePath, os, slug, relPath) {
-    const expanded = expandHome(basePath, os);
-    // The shared compiler returns POSIX-style relPaths
-    // (e.g. `<slug>/SKILL.md` or `.cursor/rules/<slug>.mdc`). For
-    // Cursor specifically the user's `basePath` already points at
-    // `.cursor/rules/`, so we collapse the leading `.cursor/rules/`
-    // to avoid the path duplicating to `.cursor/rules/.cursor/rules/`.
-    const collapsed = agent === 'cursor' && relPath.startsWith('.cursor/rules/')
-        ? relPath.slice('.cursor/rules/'.length)
-        : relPath;
-    const file = join(expanded, ...collapsed.split('/'));
-    const dir = file.slice(0, file.length - collapsed.split('/').slice(-1)[0].length - 1);
-    return {
-        dir,
-        file,
-        display: `${basePath.replace(/[\\/]+$/, '')}/${collapsed}`,
-    };
-}
-export async function deployCommand(skillName, opts = {}) {
-    track('cli_deploy', { slug: skillName, agent: opts.agent ?? 'all', dry_run: !!opts.dryRun });
-    try {
-        assertSlug(skillName);
-    }
-    catch (err) {
-        if (err instanceof InvalidSlugError) {
-            log.error(err.message);
-            process.exitCode = 1;
-            return;
-        }
-        throw err;
-    }
-    const session = await requireAuth('prave deploy');
-    if (!session)
-        return;
-    const start = Date.now();
-    // Plan-gate the multi-agent target list. Free can only deploy to
-    // Claude Code; Pro+ unlocks all 6. We compute the allowed set from
-    // PLAN_LIMITS so the Stripe-side and CLI-side stay in lockstep.
-    const me = await fetchMyPlan();
-    const allowedAgents = new Set(me.limits.multi_agent_targets);
-    if (allowedAgents.size === 0) {
-        log.warn(`Your ${me.limits.label} plan can't deploy to any agent.`);
-        log.dim(formatUpgradeHint('explorer'));
-        process.exitCode = 1;
-        return;
-    }
-    let settings;
-    try {
-        const { data } = await api.get('/api/v1/settings/agents', true);
-        settings = data;
-    }
-    catch (err) {
-        log.error(err instanceof ApiError ? err.message : err.message);
-        process.exitCode = 1;
-        return;
-    }
-    const targetFilter = opts.agent && opts.agent.toLowerCase() !== 'all'
-        ? opts.agent.toLowerCase()
-        : null;
-    const targets = settings.enabled_agents
-        .filter((a) => allowedAgents.has(a))
-        .filter((a) => targetFilter === null || a === targetFilter);
-    // If the user picked a target their plan can't reach, tell them why.
-    if (targetFilter && !allowedAgents.has(targetFilter)) {
-        log.warn(`Deploying to ${targetFilter} requires the Pro plan. Free can only deploy to Claude Code.`);
-        log.dim(formatUpgradeHint('explorer'));
-        process.exitCode = 1;
-        return;
-    }
-    if (targets.length === 0) {
-        log.warn('No matching agents enabled. Run `prave settings` to configure.');
-        return;
-    }
-    // Load source content (local first, fall back to remote).
-    let source = await readLocalSkill(skillName);
-    if (!source) {
-        try {
-            source = await fetchRemoteSkill(skillName);
-        }
-        catch (err) {
-            log.error(err instanceof ApiError ? err.message : err.message);
-            process.exitCode = 1;
-            return;
-        }
-    }
-    const os = detectOsKey(settings.detected_os);
-    console.log(`Deploying "${chalk.bold(skillName)}" to ${targets.length} agent${targets.length === 1 ? '' : 's'}${opts.dryRun ? chalk.dim(' (dry-run)') : ''}…`);
-    const spinner = ora('Writing files…').start();
-    let okCount = 0;
-    for (const agent of targets) {
-        const meta = AGENT_REGISTRY[agent];
-        const paths = settings.skill_paths[agent] ?? meta.defaultPath;
-        const basePath = os === 'windows' ? paths.windows : paths.mac;
-        // Shared compileSkill() is the single source of truth — same
-        // function the SaaS /dashboard/compile page calls, so the CLI
-        // and the web zip produce byte-identical output for the same
-        // SKILL.md.
-        const artifact = compileSkill(source, skillName, agent);
-        const dest = buildDestPath(agent, basePath, os, skillName, artifact.path);
-        spinner.text = `→ ${meta.label}`;
-        if (opts.dryRun) {
-            okCount += 1;
-            continue;
-        }
-        try {
-            await mkdir(dest.dir, { recursive: true });
-            await writeFile(dest.file, artifact.content, 'utf8');
-            okCount += 1;
-        }
-        catch (err) {
-            spinner.warn(`Failed: ${meta.label} — ${err.message}`);
-        }
-    }
-    spinner.stop();
-    for (const agent of targets) {
-        const meta = AGENT_REGISTRY[agent];
-        const paths = settings.skill_paths[agent] ?? meta.defaultPath;
-        const basePath = os === 'windows' ? paths.windows : paths.mac;
-        const artifact = compileSkill(source, skillName, agent);
-        const dest = buildDestPath(agent, basePath, os, skillName, artifact.path);
-        const tag = artifact.converted ? chalk.dim(' (converted)') : '';
-        console.log(`${chalk.green('✓')} ${meta.label.padEnd(14)} → ${dest.display}${tag}`);
-    }
-    const elapsed = ((Date.now() - start) / 1000).toFixed(1);
-    console.log(opts.dryRun
-        ? chalk.dim(`Dry-run complete in ${elapsed}s — ${okCount} agents would receive the skill.`)
-        : chalk.dim(`Deployed in ${elapsed}s`));
-}