hanzi-browse 2.3.2 → 2.3.3

package/README.md

@@ -19,11 +19,11 @@ This installs the Chrome extension and configures your AI agent. One command, do
 ## Quick Start (API)
 
 ```bash
-npm install @hanzi/browser-agent
+npm install @hanzi-browse/sdk
 ```
 
 ```typescript
-import { HanziClient } from '@hanzi/browser-agent';
+import { HanziClient } from '@hanzi-browse/sdk';
 
 const client = new HanziClient({ apiKey: 'hic_live_...' });
 
@@ -129,6 +129,8 @@ browser_start("Check hotel prices in Shibuya")
 | `HANZI_BROWSE_MAX_SESSIONS` | `5` | Max concurrent browser tasks |
 | `HANZI_BROWSE_TIMEOUT_MS` | `300000` | Task timeout (ms) |
 | `WS_RELAY_PORT` | `7862` | WebSocket relay port |
+| `POSTHOG_API_KEY` | unset | Enables PostHog analytics for local CLI telemetry, the dashboard build, the managed backend, and example apps |
+| `POSTHOG_HOST` | `https://us.i.posthog.com` | Override the PostHog host for all server-side capture calls and dashboard initialization |
 
 ## Skills
 

package/dist/agent/domain-skills.json

@@ -61,6 +61,32 @@
   },
   {
     "domain": "amazon.com",
-    "skill": "Amazon best practices:\n- Use the search bar at the top for product search\n- Filter results using the left sidebar (price, ratings, Prime, etc.)\n- Click 'Add to Cart' or 'Buy Now' to purchase\n- Product details and reviews are on the product page\n- Check seller information and shipping times before purchasing"
+    "skill": "Amazon UI patterns:\n- Prefer the top search bar or a direct search URL for product discovery\n- The first fold may be dominated by sponsored modules or Amazon brand carousels before standard results\n- Result cards can show total price, unit price, ratings, delivery promises, variation links, and inline Add to Cart buttons all at once\n- Watch carefully for subtle labels such as 'Sponsored' or 'Featured from Amazon brands'\n- Location/shipping prompts can change delivery wording and result context, so verify destination-sensitive text before extracting prices"
+  },
+  {
+    "domain": "ebay.com",
+    "skill": "eBay UI patterns:\n- Search results usually show title, condition, price, shipping, and location directly on the card\n- Headline price is often incomplete until you also check shipping cost, coupon text, and 'Best Offer' language\n- Sponsored placements and featured carousels can interrupt the organic result list\n- Use condition and shipping origin early to filter out weak matches\n- Be cautious with range prices and urgency labels like 'Last one' or watcher counts; they do not guarantee a clean fixed-price purchase path"
+  },
+  {
+    "domain": "walmart.ca",
+    "antiBot": true,
+    "skill": "Walmart.ca UI patterns:\n- Search results often expose enough information to compare products before opening a product page\n- Cards commonly include brand, title, price, ratings, fulfillment messaging, and promo details such as Subscribe to Save or pickup thresholds\n- Walmart.com may first present a storefront or region-selection step and later a human-verification blocker ('Press & Hold' challenge); validation was more reliable on Walmart.ca\n- On Walmart.ca product pages, verify one-time price separately from Subscribe to Save pricing and check pickup, express delivery, and standard delivery messages individually\n- Treat promo labels, fulfillment thresholds, and returns messaging as separate signals and verify them individually\n- If you hit a 'Press & Hold' or 'verify you are human' challenge, STOP and tell the user — never attempt to bypass"
+  },
+  {
+    "domain": "target.com",
+    "skill": "Target UI patterns:\n- Result cards usually include title, review count, price, promo messaging, and a persistent Add to Cart button\n- Price formatting can mix ranges, sale pricing, regular pricing, and per-unit math, so read the full price block carefully\n- Promo text such as Target gift card offers or 'Highly rated' badges appears frequently and can distract from the base price\n- Fulfillment filters are easy to see near the top, but card-level availability may still need a deeper click\n- Search results can include adjacent-category items, so confirm the exact product type from the title before acting"
+  },
+  {
+    "domain": "zillow.com",
+    "antiBot": true,
+    "skill": "Zillow UI patterns (rentals):\n- Sign in first for full contact info and saved searches; anonymous users see degraded data\n- Use 'For Rent' in the top nav, then refine by price, beds, and 'Move-in Date'\n- Results have a split map + list view — switch to list view for cleaner data extraction\n- Listing cards include price, beds/baths, address, and 'Apply' or 'Request a tour' buttons\n- 'Request a tour' and 'Contact' buttons submit forms — draft the message and wait for explicit user approval before clicking submit\n- Never enter SSN, payment info, or background check data without confirming the user is on an official Zillow Application flow\n- Zillow frequently serves a CAPTCHA / 'Press & Hold' challenge for automated traffic — if you hit one, STOP and tell the user, do not bypass"
+  },
+  {
+    "domain": "apartments.com",
+    "skill": "Apartments.com UI patterns:\n- Top filter bar: location, price, beds, move-in date, amenities — apply them before reading results\n- Listing cards include price range, beds/baths, address, and a 'Send Message' or 'Contact' button\n- Many listings have a built-in multi-step application flow — each step is clearly labeled; stop before 'Submit Application' and confirm with the user\n- 'Send Message' opens an inline form — draft the message, show it to the user, wait for approval before submitting\n- Pricing is often shown as a range ($X-$Y) because individual units vary; click into the listing for per-unit prices\n- Response times for large property managers are usually fast (hours); individual landlords slower\n- Do not enter SSN, credit-card, or bank info without explicit user confirmation that they want to proceed with a real application"
+  },
+  {
+    "domain": "craigslist.org",
+    "skill": "Craigslist UI patterns (apartments / housing):\n- URL pattern: https://[city].craigslist.org/search/apa?minAsk={min}&maxAsk={max}&bedrooms={n}\n- Sort by 'newest' to avoid stale listings — older listings are frequently scams or already rented\n- Listings may or may not have photos; listings without photos are higher risk, flag them\n- Contact is always via an anonymized email relay — no built-in application flow\n- Scam flags to warn the user about: price >25% below market, 'owner overseas', 'send deposit to hold', asks to text/WhatsApp before viewing, generic stock photos\n- Never follow links off craigslist for a 'verified listings site' — those are almost always phishing\n- Show the user any inquiry message before sending, and wait for explicit approval"
   }
 ]

package/dist/agent/system-prompt.js

@@ -13,9 +13,13 @@ export function buildSystemPrompt(taskUrl) {
     const blocks = [
         {
             type: "text",
-            text: `You are a web automation assistant with browser tools. Your priority is to complete the user's request efficiently and autonomously.
+            text: `You are Hanzi Browse, a browsing sub-agent driving the user's own Chrome browser — with all their logins, cookies, and sessions already in place. A host agent (Claude Code, Cursor, Codex, etc.) has delegated a task to you. Your job is to complete that task autonomously using the browser tools below, and return a concise answer.
 
-Browser tasks often require long-running, agentic capabilities. When you encounter a user request that feels time-consuming or extensive in scope, you should be persistent and use all available context needed to accomplish the task. The user expects you to work autonomously until the task is complete. Do not ask for permission - just do it.
+You are NOT a step-by-step executor reading a script. You are an agent. You decide what to click, what to type, what to wait for, and when you're done. The host agent gave you a goal in natural language; figure out the steps yourself and complete the goal.
+
+When the host agent sends you a follow-up via browser_message, it's course-correcting or refining the task — treat it as the latest instruction from the user and continue from the current browser state.
+
+You are persistent. Long or multi-step tasks are expected. The host agent expects you to work until the task is complete. Do not ask for permission — just do it.
 
 <behavior_instructions>
 The current date is ${dateStr}, ${timeStr}.

package/dist/cli/setup.d.ts

@@ -10,6 +10,8 @@ interface AgentConfig {
     method: 'json-merge' | 'cli-command';
     detect: () => boolean;
     configPath?: () => string;
+    configSection?: 'mcpServers' | 'servers' | 'context_servers';
+    legacyConfigSections?: ('mcpServers' | 'servers' | 'context_servers')[];
     cliCommand?: string;
     skillsDir?: () => string;
 }
@@ -22,6 +24,7 @@ interface AgentRegistryDeps {
     home?: string;
     plat?: NodeJS.Platform;
     appData?: string;
+    xdgConfigHome?: string;
     pathExists?: (path: string) => boolean;
     runCommand?: (command: string, options?: any) => Buffer | string;
 }
@@ -41,6 +44,7 @@ interface BrowserDetectionDeps {
 }
 export declare function getAgentRegistry(deps?: AgentRegistryDeps): AgentConfig[];
 export declare function mergeJsonConfig(configPath: string, deps?: JsonConfigDeps): SetupResult;
+export declare function mergeJsonConfigAtKey(configPath: string, configSection: 'mcpServers' | 'servers' | 'context_servers', deps?: JsonConfigDeps, legacyConfigSections?: ('mcpServers' | 'servers' | 'context_servers')[]): SetupResult;
 interface BrowserInfo {
     name: string;
     slug: string;
@@ -57,5 +61,7 @@ export declare function buildSystemOpenCommand(url: string, plat: NodeJS.Platfor
 export declare function runSetup(options?: {
     only?: string;
     yes?: boolean;
+    all?: boolean;
+    skills?: string[];
 }): Promise<void>;
 export {};

package/dist/cli/setup.js

@@ -69,6 +69,7 @@ export function getAgentRegistry(deps = {}) {
     const home = deps.home ?? homedir();
     const plat = deps.plat ?? platform();
     const appData = deps.appData ?? process.env.APPDATA ?? join(home, 'AppData', 'Roaming');
+    const xdgConfigHome = deps.xdgConfigHome ?? process.env.XDG_CONFIG_HOME ?? join(home, '.config');
     const pathExists = deps.pathExists ?? existsSync;
     const runCommand = deps.runCommand ?? execSync;
     const hasCli = (bin) => {
@@ -112,9 +113,39 @@ export function getAgentRegistry(deps = {}) {
             slug: 'vscode',
             method: 'json-merge',
             configPath: () => join(home, '.vscode', 'mcp.json'),
+            configSection: 'servers',
+            legacyConfigSections: ['mcpServers'],
             skillsDir: () => join(home, '.vscode', 'skills'),
             detect: () => pathExists(join(home, '.vscode')),
         },
+        {
+            name: 'Zed',
+            slug: 'zed',
+            method: 'json-merge',
+            configPath: () => {
+                if (plat === 'darwin')
+                    return join(home, 'Library', 'Application Support', 'Zed', 'settings.json');
+                if (plat === 'win32')
+                    return join(appData, 'Zed', 'settings.json');
+                return join(xdgConfigHome, 'zed', 'settings.json');
+            },
+            configSection: 'context_servers',
+            detect: () => {
+                if (plat === 'darwin')
+                    return pathExists(join(home, 'Library', 'Application Support', 'Zed'));
+                if (plat === 'win32')
+                    return pathExists(join(appData, 'Zed'));
+                return pathExists(join(xdgConfigHome, 'zed'));
+            },
+        },
+        {
+            name: 'Neovim',
+            slug: 'neovim',
+            method: 'json-merge',
+            configPath: () => join(xdgConfigHome, 'mcphub', 'servers.json'),
+            configSection: 'servers',
+            detect: () => pathExists(join(xdgConfigHome, 'mcphub')),
+        },
         {
             name: 'Codex',
             slug: 'codex',
@@ -181,6 +212,24 @@ function stripJsonComments(text) {
         .replace(/\/\*[\s\S]*?\*\//g, '');
 }
 export function mergeJsonConfig(configPath, deps = {}) {
+    return mergeJsonConfigAtKey(configPath, 'mcpServers', deps);
+}
+function removeLegacyHanziEntries(config, configSection, legacyConfigSections = []) {
+    let changed = false;
+    for (const legacySection of legacyConfigSections) {
+        if (legacySection === configSection)
+            continue;
+        const section = config[legacySection];
+        if (section && typeof section === 'object' && section['hanzi-browser']) {
+            delete section['hanzi-browser'];
+            changed = true;
+            if (Object.keys(section).length === 0)
+                delete config[legacySection];
+        }
+    }
+    return changed;
+}
+export function mergeJsonConfigAtKey(configPath, configSection, deps = {}, legacyConfigSections = []) {
     const agentName = configPath;
     const pathExists = deps.pathExists ?? existsSync;
     const readTextFile = deps.readTextFile ?? readFileSync;
@@ -190,7 +239,7 @@ export function mergeJsonConfig(configPath, deps = {}) {
     try {
         if (!pathExists(configPath)) {
             ensureDir(join(configPath, '..'), { recursive: true });
-            const config = { mcpServers: { "hanzi-browser": MCP_ENTRY } };
+            const config = { [configSection]: { "hanzi-browser": MCP_ENTRY } };
             writeTextFile(configPath, JSON.stringify(config, null, 2) + '\n');
             return { agent: agentName, status: 'configured', detail: `created ${configPath}` };
         }
@@ -206,20 +255,25 @@ export function mergeJsonConfig(configPath, deps = {}) {
             catch {
                 const bakPath = configPath + '.bak';
                 copyFile(configPath, bakPath);
-                config = { mcpServers: { "hanzi-browser": MCP_ENTRY } };
+                config = { [configSection]: { "hanzi-browser": MCP_ENTRY } };
                 writeTextFile(configPath, JSON.stringify(config, null, 2) + '\n');
                 return { agent: agentName, status: 'configured', detail: `backed up malformed config to ${bakPath}` };
             }
         }
-        if (config.mcpServers?.["hanzi-browser"]) {
-            const existing = config.mcpServers["hanzi-browser"];
+        const removedLegacyEntry = removeLegacyHanziEntries(config, configSection, legacyConfigSections);
+        if (config[configSection]?.["hanzi-browser"]) {
+            const existing = config[configSection]["hanzi-browser"];
             if (existing.command === MCP_ENTRY.command && JSON.stringify(existing.args) === JSON.stringify(MCP_ENTRY.args)) {
+                if (removedLegacyEntry) {
+                    writeTextFile(configPath, JSON.stringify(config, null, 2) + '\n');
+                    return { agent: agentName, status: 'configured', detail: `migrated legacy hanzi-browser entry in ${configPath}` };
+                }
                 return { agent: agentName, status: 'already-configured', detail: configPath };
             }
         }
-        if (!config.mcpServers)
-            config.mcpServers = {};
-        config.mcpServers["hanzi-browser"] = MCP_ENTRY;
+        if (!config[configSection])
+            config[configSection] = {};
+        config[configSection]["hanzi-browser"] = MCP_ENTRY;
         writeTextFile(configPath, JSON.stringify(config, null, 2) + '\n');
         return { agent: agentName, status: 'configured', detail: `merged into ${configPath}` };
     }
@@ -563,8 +617,10 @@ async function injectManagedKey(apiKey, agents) {
                 if (existsSync(configPath)) {
                     const raw = readFileSync(configPath, 'utf-8');
                     const config = JSON.parse(raw);
-                    if (config.mcpServers?.["hanzi-browser"]) {
-                        config.mcpServers["hanzi-browser"] = managedEntry;
+                    const configSection = agent.configSection ?? 'mcpServers';
+                    removeLegacyHanziEntries(config, configSection, agent.legacyConfigSections ?? []);
+                    if (config[configSection]?.["hanzi-browser"]) {
+                        config[configSection]["hanzi-browser"] = managedEntry;
                         writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
                         console.log(`     ${c.green('✓')}  Updated ${agent.name} with managed API key`);
                     }
@@ -697,7 +753,12 @@ function disconnectRelay() {
         setTimeout(() => { console.error = origError; }, 500);
     }
 }
-// ── Skill installation ──────────────────────────────────────────────────
+const VALID_CATEGORIES = ['core', 'productivity', 'marketing', 'life'];
+const CATEGORY_BUNDLES = [
+    { cat: 'productivity', label: 'Productivity', summary: 'testing, audits, data extraction, SEO' },
+    { cat: 'marketing', label: 'Marketing & growth', summary: 'social posting, prospecting, competitor research' },
+    { cat: 'life', label: 'Personal automation', summary: 'apartments, jobs' },
+];
 function getSkillsSource() {
     // Skills are bundled in the npm package at ../skills/ relative to dist/cli/
     const fromDist = join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'skills');
@@ -707,36 +768,157 @@ function getSkillsSource() {
     const fromSrc = join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'skills');
     return fromSrc;
 }
-const SKILL_NAMES = ['hanzi-browse', 'e2e-tester', 'social-poster', 'linkedin-prospector', 'a11y-auditor', 'x-marketer'];
-async function installSkills(agents, isInteractive) {
-    const skillsSource = getSkillsSource();
+function parseSkillFrontmatter(content) {
+    const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!match)
+        return null;
+    const result = {};
+    for (const line of match[1].split(/\r?\n/)) {
+        const m = line.match(/^(\w+):\s*(.*)$/);
+        if (!m)
+            continue;
+        const key = m[1];
+        const value = m[2].trim();
+        if (key === 'description')
+            result.description = value;
+        else if (key === 'category' && VALID_CATEGORIES.includes(value)) {
+            result.category = value;
+        }
+    }
+    return result;
+}
+function discoverSkills(skillsSource) {
     if (!existsSync(skillsSource))
-        return; // No skills bundled
+        return [];
+    const skills = [];
+    for (const entry of readdirSync(skillsSource, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        const skillPath = join(skillsSource, entry.name);
+        const skillMd = join(skillPath, 'SKILL.md');
+        if (!existsSync(skillMd))
+            continue;
+        const meta = parseSkillFrontmatter(readFileSync(skillMd, 'utf-8'));
+        if (!meta)
+            continue;
+        skills.push({
+            name: entry.name,
+            description: meta.description || '',
+            // Skills without an explicit category default to productivity — a safe
+            // "opt-in bundle" rather than forcing everyone to get it by default.
+            category: meta.category ?? 'productivity',
+            path: skillPath,
+        });
+    }
+    return skills;
+}
+async function promptSkillCategories(skills) {
+    const selected = new Set();
+    const coreSkills = skills.filter(s => s.category === 'core');
+    for (const s of coreSkills)
+        selected.add(s.name);
+    const byCategory = new Map();
+    for (const s of skills) {
+        if (s.category === 'core')
+            continue;
+        const cat = s.category;
+        if (!byCategory.has(cat))
+            byCategory.set(cat, []);
+        byCategory.get(cat).push(s);
+    }
+    const bundles = [];
+    for (const b of CATEGORY_BUNDLES) {
+        const catSkills = byCategory.get(b.cat);
+        if (catSkills && catSkills.length > 0)
+            bundles.push({ ...b, skills: catSkills });
+    }
+    if (bundles.length === 0)
+        return selected;
+    console.log('');
+    console.log(`  ${c.dim('step 2b')}  ${c.bold('Skills')}`);
+    console.log(`  ${c.dim('       Skills tell your AI agent when and how to use Hanzi for specific workflows.')}\n`);
+    if (coreSkills.length > 0) {
+        console.log(`     ${c.green('✓')}  ${c.bold('Core')} ${c.dim(`(always installed)`)}`);
+        for (const s of coreSkills)
+            console.log(`        ${c.dim(s.name)}`);
+        console.log('');
+    }
+    console.log(`     ${c.dim('Optional bundles:')}`);
+    bundles.forEach((b, i) => {
+        console.log(`     ${c.bold(String(i + 1))}  ${b.label} ${c.dim(`(${b.skills.length} skills — ${b.summary})`)}`);
+        console.log(`        ${c.dim(b.skills.map(s => s.name).join(', '))}`);
+    });
+    console.log('');
+    const answer = await ask('Install bundles (e.g. "1 2", "all", or "none"): ');
+    const normalized = answer.trim().toLowerCase();
+    if (normalized === 'all') {
+        for (const b of bundles)
+            for (const s of b.skills)
+                selected.add(s.name);
+    }
+    else if (normalized && normalized !== 'none') {
+        const picks = new Set(normalized.split(/[\s,]+/).map(n => parseInt(n, 10)).filter(n => !isNaN(n)));
+        for (const n of picks) {
+            const bundle = bundles[n - 1];
+            if (bundle)
+                for (const s of bundle.skills)
+                    selected.add(s.name);
+        }
+    }
+    return selected;
+}
+async function installSkills(agents, isInteractive, options = {}) {
+    const skillsSource = getSkillsSource();
+    const discovered = discoverSkills(skillsSource);
+    if (discovered.length === 0)
+        return;
     const agentsWithSkills = agents.filter(a => a.skillsDir);
     if (agentsWithSkills.length === 0)
         return;
-    const out = isInteractive ? console.log : log;
+    // Decide which skills to install
+    let selected;
+    if (options.all) {
+        selected = new Set(discovered.map(s => s.name));
+    }
+    else if (options.skills && options.skills.length > 0) {
+        selected = new Set(options.skills);
+        for (const s of discovered)
+            if (s.category === 'core')
+                selected.add(s.name);
+    }
+    else if (isInteractive) {
+        selected = await promptSkillCategories(discovered);
+    }
+    else {
+        selected = new Set(discovered.filter(s => s.category === 'core').map(s => s.name));
+    }
+    if (selected.size === 0)
+        return;
+    const skillsToInstall = discovered.filter(s => selected.has(s.name));
     if (isInteractive) {
         console.log('');
-        console.log(`  ${c.dim('       Installing browser automation skills...')}`);
+        console.log(`  ${c.dim('       Installing ' + skillsToInstall.length + ' skill' + (skillsToInstall.length === 1 ? '' : 's') + '...')}`);
     }
     else {
-        log('\n     Installing skills...');
+        log(`\n  Installing ${skillsToInstall.length} skill${skillsToInstall.length === 1 ? '' : 's'}...`);
     }
     let installed = 0;
     for (const agent of agentsWithSkills) {
         const targetDir = agent.skillsDir();
         try {
-            for (const skillName of SKILL_NAMES) {
-                const src = join(skillsSource, skillName);
-                if (!existsSync(src))
-                    continue;
-                const dest = join(targetDir, skillName);
+            for (const skill of skillsToInstall) {
+                const dest = join(targetDir, skill.name);
                 mkdirSync(dest, { recursive: true });
-                // Copy SKILL.md and any supporting files
-                const files = readdirSync(src);
-                for (const file of files) {
-                    copyFileSync(join(src, file), join(dest, file));
+                // Copy SKILL.md and any flat supporting files. Subdirectories (e.g. a
+                // references/ folder) are skipped — copyFileSync on a dir throws and
+                // the skills we ship today don't need nested assets.
+                for (const file of readdirSync(skill.path)) {
+                    try {
+                        copyFileSync(join(skill.path, file), join(dest, file));
+                    }
+                    catch {
+                        // Silently skip non-file entries (directories, symlinks, etc.)
+                    }
                 }
             }
             installed++;
@@ -757,7 +939,7 @@ async function installSkills(agents, isInteractive) {
         }
     }
     if (installed > 0) {
-        const msg = `${installed} agent${installed === 1 ? '' : 's'} got ${SKILL_NAMES.length} browser skills`;
+        const msg = `${installed} agent${installed === 1 ? '' : 's'} got ${skillsToInstall.length} skill${skillsToInstall.length === 1 ? '' : 's'}`;
         if (isInteractive) {
             console.log(`\n     ${c.green('✓')}  ${msg}`);
         }
@@ -872,7 +1054,7 @@ export async function runSetup(options = {}) {
             result = runClaudeCodeSetup();
         }
         else {
-            result = mergeJsonConfig(agent.configPath());
+            result = mergeJsonConfigAtKey(agent.configPath(), agent.configSection ?? 'mcpServers', {}, agent.legacyConfigSections ?? []);
         }
         results.push({ ...result, agent: agent.name });
         await sleep(150);
@@ -905,7 +1087,7 @@ export async function runSetup(options = {}) {
         }
     }
     // ── Step 2b: Install skills ──
-    await installSkills(detected, interactive);
+    await installSkills(detected, interactive, { all: options.all, skills: options.skills });
     // ── Step 3: Access mode ──
     let accessMode = 'byom';
     if (interactive) {

package/dist/cli.js

@@ -397,13 +397,24 @@ async function cmdSetup() {
     const { runSetup } = await import('./cli/setup.js');
     let only;
     let yes = false;
+    let all = false;
+    let skills;
     for (let i = 1; i < args.length; i++) {
-        if (args[i] === '--only' && args[i + 1])
+        const arg = args[i];
+        if (arg === '--only' && args[i + 1])
             only = args[++i];
-        if (args[i] === '--yes' || args[i] === '-y')
+        else if (arg === '--yes' || arg === '-y')
             yes = true;
+        else if (arg === '--all-skills' || arg === '--all')
+            all = true;
+        else if (arg === '--skills' && args[i + 1]) {
+            skills = args[++i].split(',').map(s => s.trim()).filter(Boolean);
+        }
+        else if (arg.startsWith('--skills=')) {
+            skills = arg.slice('--skills='.length).split(',').map(s => s.trim()).filter(Boolean);
+        }
     }
-    await runSetup({ only, yes });
+    await runSetup({ only, yes, all, skills });
 }
 function cmdHelp() {
     console.log(`
@@ -443,6 +454,9 @@ Commands:
 
   setup                     Auto-detect AI agents and configure MCP
     --only <agent>          Only configure one agent (claude-code, cursor, windsurf, claude-desktop)
+    --yes, -y               Non-interactive mode (installs core skill only)
+    --all                   Install every bundled skill (skip the prompt)
+    --skills a,b,c          Install just these skills (core always included)
 
   skills                    List available agent skills
   skills install <name>     Download a skill into your project