openads-ai 0.3.0 → 0.5.0

package/dist/doctor.js

@@ -92,6 +92,45 @@ export async function runDoctor() {
         console.log(`  ${chalk.red('✗')} uvx: Not installed. Run 'curl -LsSf https://astral.sh/uv/install.sh | sh'`);
         hasErrors = true;
     }
+    // ─── Local AI Check ────────────────────────────────────────────────
+    if (config?.localBaseUrl) {
+        console.log(`\n${chalk.bold('Local AI')}`);
+        const baseUrl = config.localBaseUrl.replace(/\/$/, '');
+        // 1. Check if the endpoint is reachable
+        try {
+            const tagsUrl = `${baseUrl.replace('/v1', '')}/api/tags`;
+            const res = await fetch(tagsUrl, { signal: AbortSignal.timeout(3000) });
+            if (res.ok) {
+                const data = await res.json();
+                const models = (data.models || []).map((m) => m.name || m.model || '');
+                console.log(`  ${chalk.green('✓')} Ollama server: Reachable at ${baseUrl}`);
+                // 2. Check if the configured model is pulled
+                const configuredModel = config.provider.includes('/')
+                    ? config.provider.split('/').pop()
+                    : config.provider;
+                const modelFound = models.some(m => m === configuredModel || m.startsWith(configuredModel.split(':')[0]));
+                if (modelFound) {
+                    console.log(`  ${chalk.green('✓')} Model: ${chalk.cyan(configuredModel)} is available`);
+                }
+                else {
+                    console.log(`  ${chalk.red('✗')} Model: ${chalk.cyan(configuredModel)} not found in Ollama`);
+                    console.log(`     ${chalk.gray('Available models:')} ${models.length > 0 ? models.join(', ') : 'none'}`);
+                    console.log(`     ${chalk.gray(`Run: ollama pull ${configuredModel}`)}`);
+                    hasErrors = true;
+                }
+            }
+            else {
+                console.log(`  ${chalk.red('✗')} Ollama server: Not reachable at ${baseUrl}`);
+                console.log(`     ${chalk.gray('Start Ollama with: ollama serve')}`);
+                hasErrors = true;
+            }
+        }
+        catch (e) {
+            console.log(`  ${chalk.red('✗')} Ollama server: Connection failed — ${e.message}`);
+            console.log(`     ${chalk.gray('Make sure Ollama is running: ollama serve')}`);
+            hasErrors = true;
+        }
+    }
     if (hasErrors) {
         console.log(`\n${chalk.red('Some checks failed. Please run `openads setup` to configure your environment.')}`);
         process.exit(1);

package/dist/mcp-extension.js

@@ -4,16 +4,20 @@ import { hasGlobalRtk } from "./token-optimizer.js";
 import fs from "fs";
 import path from "path";
 import os from "os";
-// ─── Essential Campaign Analysis & Audit Tools ──────────────────────
-// Filtering down from 39 tools to 11 essential campaign performance tools
-// massively optimizes local LLM context, prevents tool confusion, and breaks repeating loops.
-const ESSENTIAL_META_TOOLS = new Set([
+// ─── Tier-Based Tool Filtering ────────────────────────────────────
+// Express → skip MCP entirely (handled by OPENADS_SKIP_MCP env var)
+// Standard → 6 read-only discovery + performance tools
+// Full → 11 tools (read + write operations)
+const STANDARD_META_TOOLS = new Set([
     "get_ad_accounts",
     "list_campaigns",
     "get_campaign",
     "get_campaign_performance",
     "get_insights",
-    "list_ad_sets",
+    "list_ad_sets"
+]);
+const FULL_META_TOOLS = new Set([
+    ...STANDARD_META_TOOLS,
     "list_ads",
     "get_creative_performance",
     "pause_campaign",
@@ -33,8 +37,14 @@ export default async function (pi) {
     catch (e) {
         return;
     }
+    // Skip MCP tool registration during Autoresearch.
+    // The model never needs live ad platform tools when generating hypotheses,
+    // and each tool schema consumes ~150 tokens of scarce context.
+    if (process.env.OPENADS_SKIP_MCP === '1') {
+        return;
+    }
     const clients = [];
-    // ─── Google Ads MCP ───────────────────────────────────────────────
+    // ─── Google Ads MCP ────────────────────────────────────────────────────
     if (config.connectGoogle) {
         try {
             const useRtk = hasGlobalRtk();
@@ -53,7 +63,7 @@ export default async function (pi) {
             console.error(`[OpenAds MCP] Failed to connect to Google Ads: ${err.message}`);
         }
     }
-    // ─── Meta Ads MCP (Local Stdio Server via meta-ads-mcp) ───────────
+    // ─── Meta Ads MCP (Local Stdio Server via meta-ads-mcp) ─────────────────
     if (config.metaToken) {
         try {
             const useRtk = hasGlobalRtk();
@@ -77,12 +87,14 @@ export default async function (pi) {
         }
     }
     // ─── Dynamically Register Tools ──────────────────────────────────
+    const tier = process.env.OPENADS_TIER || 'standard';
+    const allowedMetaTools = tier === 'full' ? FULL_META_TOOLS : STANDARD_META_TOOLS;
     for (const { name: serverName, client } of clients) {
         try {
             const toolsResult = await client.listTools();
             for (const tool of toolsResult.tools) {
-                // Filter out advanced/OAuth/developer tools for Meta Ads to keep the LLM context extremely clean
-                if (serverName === "meta-ads" && !ESSENTIAL_META_TOOLS.has(tool.name)) {
+                // Filter Meta tools by tier (standard=6 read-only, full=11 read+write)
+                if (serverName === "meta-ads" && !allowedMetaTools.has(tool.name)) {
                     continue;
                 }
                 pi.registerTool({
@@ -98,7 +110,7 @@ export default async function (pi) {
                                 return {
                                     content: [{
                                             type: "text",
-                                            text: `Blocking execution of '${tool.name}' because OpenAds is in Audit Mode (Safe/Read-only). Under Audit Mode, campaign write operations are disabled. To execute active changes, please toggle to Launch Mode in Settings (\`openads setup\`).`
+                                            text: `Blocking execution of '${tool.name}' because OpenAds is in Audit Mode (Safe/Read-only). Campaign write operations are disabled. Toggle to Launch Mode in Settings (openads setup) to make changes.`
                                         }],
                                     details: {},
                                     isError: true,
@@ -147,6 +159,123 @@ export default async function (pi) {
             console.error(`[OpenAds MCP] Failed to register tools for ${serverName}: ${err.message}`);
         }
     }
+    // ─── Facebook Page Organic Posting ──────────────────────────────
+    if (config.facebookPageToken && config.facebookPageId) {
+        const FB_API = 'https://graph.facebook.com/v21.0';
+        const PAGE_ID = config.facebookPageId;
+        const PAGE_TOKEN = config.facebookPageToken;
+        // Read: get recent page posts (Standard + Full)
+        pi.registerTool({
+            name: 'get_facebook_page_posts',
+            label: 'Get Facebook Page Posts',
+            description: 'Retrieve recent organic posts from your Facebook Page. Call this before drafting new content to review posting history and avoid repeating topics.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    limit: {
+                        type: 'number',
+                        description: 'Number of recent posts to retrieve (1-25, default 10)',
+                    },
+                },
+            },
+            async execute(toolCallId, params, signal, onUpdate, ctx) {
+                const limit = Math.min(params.limit || 10, 25);
+                try {
+                    const res = await fetch(`${FB_API}/${PAGE_ID}/posts?fields=message,created_time,full_picture,permalink_url&limit=${limit}&access_token=${PAGE_TOKEN}`);
+                    const data = await res.json();
+                    if (data.error)
+                        throw new Error(data.error.message);
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify(data.data, null, 2) }],
+                        details: {},
+                    };
+                }
+                catch (err) {
+                    return {
+                        content: [{ type: 'text', text: `Error fetching posts: ${err.message}` }],
+                        details: {},
+                        isError: true,
+                    };
+                }
+            },
+        });
+        // Write: publish a post (Full tier only, gated by audit/launch mode)
+        if (tier === 'full') {
+            pi.registerTool({
+                name: 'post_to_facebook_page',
+                label: 'Post to Facebook Page',
+                description: 'Publish an organic text post (with optional link) to your Facebook Page.',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        message: {
+                            type: 'string',
+                            description: 'The post text content',
+                        },
+                        link: {
+                            type: 'string',
+                            description: 'Optional URL to attach as a link preview',
+                        },
+                    },
+                    required: ['message'],
+                },
+                async execute(toolCallId, params, signal, onUpdate, ctx) {
+                    const p = params;
+                    if (config.mode === 'audit') {
+                        return {
+                            content: [{
+                                    type: 'text',
+                                    text: "Blocking 'post_to_facebook_page' — OpenAds is in Audit Mode (Read-only). Switch to Launch Mode in 'openads setup' to publish.",
+                                }],
+                            details: {},
+                            isError: true,
+                        };
+                    }
+                    if (config.mode === 'launch') {
+                        const preview = p.message.length > 120 ? p.message.slice(0, 120) + '...' : p.message;
+                        const ok = await ctx.ui.confirm('Confirm Facebook Post ⚠️', `You are about to publish to your Facebook Page:\n\n"${preview}"\n${p.link ? "\nLink: " + p.link : ""}\n\nPublish now?`);
+                        if (!ok) {
+                            return {
+                                content: [{ type: 'text', text: 'Post cancelled by user.' }],
+                                details: {},
+                                isError: true,
+                            };
+                        }
+                    }
+                    try {
+                        const body = {
+                            message: p.message,
+                            access_token: PAGE_TOKEN,
+                        };
+                        if (p.link)
+                            body.link = p.link;
+                        const res = await fetch(`${FB_API}/${PAGE_ID}/feed`, {
+                            method: 'POST',
+                            headers: { 'Content-Type': 'application/json' },
+                            body: JSON.stringify(body),
+                        });
+                        const data = await res.json();
+                        if (data.error)
+                            throw new Error(data.error.message);
+                        return {
+                            content: [{
+                                    type: 'text',
+                                    text: `✅ Published!\nPost ID: ${data.id}\nURL: https://www.facebook.com/${data.id.replace("_", "/posts/")}`,
+                                }],
+                            details: {},
+                        };
+                    }
+                    catch (err) {
+                        return {
+                            content: [{ type: 'text', text: `Error publishing post: ${err.message}` }],
+                            details: {},
+                            isError: true,
+                        };
+                    }
+                },
+            });
+        }
+    }
     // Register clean shutdown on session exit
     pi.on("session_shutdown", async () => {
         for (const { client } of clients) {

package/dist/schedule.js

@@ -206,6 +206,8 @@ function uninstallCrontab(name) {
     });
 }
 // ─── Run a Scheduled Task ────────────────────────────────────────────
+// Applies the same mode-aware prompt + selective skill loading as the main CLI
+// so scheduled tasks work reliably on local models.
 export async function runScheduledTask(name) {
     const schedules = loadSchedules();
     const schedule = schedules.find(s => s.name === name);
@@ -247,23 +249,74 @@ export async function runScheduledTask(name) {
         env.OPENAI_BASE_URL = config.localBaseUrl;
         env.OPENAI_API_KEY = env.OPENAI_API_KEY || 'sk-local-ai-key-placeholder';
     }
-    const skillsDir = path.resolve(pkgDir, 'skills');
-    const contextDir = path.join(CONFIG_DIR, 'context');
-    const cleanModel = config.provider;
     const isLocal = !!config.localBaseUrl;
+    const cleanModel = config.provider;
     const modelIdForPi = isLocal && cleanModel.includes('/') ? cleanModel.split('/')[1] : cleanModel;
+    const skillsDir = path.resolve(pkgDir, 'skills');
+    const contextDir = path.join(CONFIG_DIR, 'context');
+    // ─── Mode-aware system prompt ───────────────────────────────────────
+    // Scheduled audit tasks use the 'default' prompt mode (they need MCP tools).
+    // Write a temporary system prompt file for this run.
+    const agentDir = path.join(CONFIG_DIR, 'agent');
+    if (!fs.existsSync(agentDir))
+        fs.mkdirSync(agentDir, { recursive: true });
+    const homeDir = os.homedir();
+    const contextPath = path.join(CONFIG_DIR, 'context', 'my-business.md');
+    const isLaunchMode = config.mode === 'launch';
+    const scheduleSystemPrompt = [
+        'You are OpenAds, an AI marketing assistant. You are running a scheduled automated task.',
+        'Your job: execute the task concisely and produce a clean, structured markdown report.',
+        'Use MCP tools to query live campaign data. Never use placeholder IDs.',
+        '',
+        '## Platform Tools',
+        '- For Meta: call get_ad_accounts() first (no params), then list_campaigns(account_id), then get_campaign_performance or get_insights.',
+        '- Anti-loop rule: never call the same tool twice in one turn.',
+        '',
+        '## Output Rules',
+        '- Structure your output as a clean markdown report with headers, tables, and bullet points.',
+        '- Flag issues clearly: 🔴 Critical | 🟡 Warning | 🟢 Opportunity.',
+        '- End with a numbered list of recommended actions.',
+        '',
+        `## Safety`,
+        `- Home directory: ${homeDir}. Never use placeholder paths.`,
+        isLaunchMode
+            ? '- Mode: Launch (Read-Write). Show a preview card and get Y/N before any write operation.'
+            : '- Mode: Audit (Read-Only). You can only read and analyze — no writes.',
+        '',
+        `## Business Context`,
+        fs.existsSync(contextPath)
+            ? `Read your business context file at ${contextPath} before starting.`
+            : 'No business context file found. Proceed with the task using available data.',
+    ].join('\n');
+    const scheduleSysPromptPath = path.join(agentDir, 'SCHEDULE-SYSTEM.md');
+    fs.writeFileSync(scheduleSysPromptPath, scheduleSystemPrompt);
+    // ─── Selective skill loading ────────────────────────────────────────
+    // Scheduled tasks are audit-type by default → load only the 3 ad platform skills.
+    // This saves ~7K tokens vs loading all 24 skills.
+    const scheduleSkills = [
+        path.join(skillsDir, 'ads', 'google-ads.md'),
+        path.join(skillsDir, 'ads', 'meta-ads.md'),
+        path.join(skillsDir, 'product-marketing.md'),
+    ].filter(p => fs.existsSync(p));
+    const skillArgs = [];
+    for (const skill of scheduleSkills) {
+        skillArgs.push('--skill', skill);
+    }
     const args = [
         piCliPath,
         '--model', modelIdForPi,
-        '--skill', skillsDir,
+        '--system-prompt', scheduleSysPromptPath,
+        ...skillArgs,
         ...(fs.existsSync(contextDir) ? ['--skill', contextDir] : []),
         '--print',
         schedule.prompt,
     ];
+    // Local models may be slow — give them up to 10 minutes
+    const timeoutMs = isLocal ? 600000 : 300000;
     const result = spawnSync('node', args, {
         env,
         encoding: 'utf8',
-        timeout: 300000, // 5 minute timeout
+        timeout: timeoutMs,
         stdio: ['ignore', 'pipe', 'pipe'],
     });
     if (result.stdout) {

package/dist/setup.js

@@ -33,7 +33,7 @@ export async function runSetup() {
         catch (e) { }
     }
     // Step 1: Model Selection
-    console.log(chalk.cyan('Step 1/4: Choose your AI model\n'));
+    console.log(chalk.cyan('Step 1/7: Choose your AI model\n'));
     const providerChoices = [
         { name: 'google', message: 'Google (Gemini)' },
         { name: 'openai', message: 'OpenAI (ChatGPT)' },
@@ -210,8 +210,47 @@ export async function runSetup() {
         console.log(chalk.green(`\n✓ Local AI configured — ready to connect to ${localBaseUrl}.\n`));
     }
     console.log(chalk.gray('─────────────────────────────────────────\n'));
-    // Step 2: Choose operational mode
-    console.log(chalk.cyan('Step 2/5: Choose operational mode\n'));
+    // Step 2: Experience Tier
+    console.log(chalk.cyan('Step 2/7: Choose your experience tier\n'));
+    console.log('  OpenAds adapts its depth based on your model\'s capability:\n');
+    console.log(`  ${chalk.yellow('⚡ Express')}   — Fast & reliable. Compact prompts, structured output.`);
+    console.log(`  ${chalk.blue('📊 Standard')}  — Balanced depth. Live data tools, detailed reports.`);
+    console.log(`  ${chalk.magenta('🚀 Full')}      — Maximum depth. Multi-step analysis, creative exploration.\n`);
+    // Auto-detect recommended tier based on model choice
+    const isLocalSetup = provider === 'local';
+    const modelLower = (selectedModel || localModelName || customModel || '').toLowerCase();
+    let suggestedTier = 'full';
+    if (isLocalSetup) {
+        suggestedTier = (modelLower.includes('70b') || modelLower.includes('72b') || modelLower.includes('405b')) ? 'standard' : 'express';
+    }
+    else {
+        const isLiteTier = modelLower.includes('flash') || modelLower.includes('mini') || modelLower.includes('haiku');
+        suggestedTier = isLiteTier ? 'standard' : 'full';
+    }
+    const tierChoices = [
+        { name: 'express', message: `${chalk.yellow('⚡')} Express  — Best for: Llama 8B, Mistral 7B, Phi-3  ${suggestedTier === 'express' ? chalk.green('← Recommended') : ''}` },
+        { name: 'standard', message: `${chalk.blue('📊')} Standard — Best for: Gemini Flash, GPT-4o Mini, Llama 70B  ${suggestedTier === 'standard' ? chalk.green('← Recommended') : ''}` },
+        { name: 'full', message: `${chalk.magenta('🚀')} Full     — Best for: GPT-4o, Claude Sonnet, Gemini Pro  ${suggestedTier === 'full' ? chalk.green('← Recommended') : ''}` },
+    ];
+    let initialTierIndex = tierChoices.findIndex(c => c.name === (existingConfig.tier || suggestedTier));
+    if (initialTierIndex === -1)
+        initialTierIndex = tierChoices.findIndex(c => c.name === suggestedTier);
+    const { selectedTier } = await enquirer.prompt({
+        type: 'select',
+        name: 'selectedTier',
+        message: 'Select your experience tier:',
+        choices: tierChoices,
+        initial: initialTierIndex
+    });
+    const tierLabels = {
+        express: `${chalk.yellow('⚡ Express')}`,
+        standard: `${chalk.blue('📊 Standard')}`,
+        full: `${chalk.magenta('🚀 Full')}`,
+    };
+    console.log(chalk.green(`\n✓ Experience tier: ${tierLabels[selectedTier]}.\n`));
+    console.log(chalk.gray('─────────────────────────────────────────\n'));
+    // Step 3: Choose operational mode
+    console.log(chalk.cyan('Step 3/7: Choose operational mode\n'));
     console.log('OpenAds has two operational modes:');
     console.log(` - ${chalk.green.bold('Audit Mode (Safe / Read-only)')}: AI can analyze performance, find budget waste, and recommend strategies. Zero risk.`);
     console.log(` - ${chalk.red.bold('Launch Mode (Read-Write)')}: AI is authorized to optimize bids, modify budgets, and launch ads (always requires confirmation).\n`);
@@ -228,8 +267,8 @@ export async function runSetup() {
     mode = modeAnswers.selectedMode;
     console.log(chalk.green(`\n✓ Operational mode configured: ${mode === 'launch' ? 'Launch Mode (Read-Write)' : 'Audit Mode (Safe / Read-only)'}.\n`));
     console.log(chalk.gray('─────────────────────────────────────────\n'));
-    // Step 3: Google Ads
-    console.log(chalk.cyan('Step 3/5: Connect Google Ads (optional)\n'));
+    // Step 4: Google Ads
+    console.log(chalk.cyan('Step 4/7: Connect Google Ads (optional)\n'));
     console.log('OpenAds can read and analyze your Google Ads campaigns, keywords, and performance.\n');
     const { connectGoogle } = await enquirer.prompt({
         type: 'confirm',
@@ -268,7 +307,7 @@ export async function runSetup() {
     }
     console.log(chalk.gray('─────────────────────────────────────────\n'));
     // Step 4: Meta Ads
-    console.log(chalk.cyan('Step 4/5: Connect Meta Ads (optional)\n'));
+    console.log(chalk.cyan('Step 5/7: Connect Meta Ads (optional)\n'));
     console.log('OpenAds can read your Meta campaigns, creatives, and audience performance.\n');
     let metaToken = '';
     const { connectMeta } = await enquirer.prompt({
@@ -374,8 +413,98 @@ export async function runSetup() {
         }
     }
     console.log(chalk.gray('─────────────────────────────────────────\n'));
-    // Step 5: Business Context
-    console.log(chalk.cyan('Step 5/5: Tell me about your business\n'));
+    // Step 6: Business Context
+    // Step 6/7: Facebook Page for organic posting
+    console.log(chalk.cyan('Step 6/7: Connect Facebook Page for organic posts (optional)\n'));
+    console.log('OpenAds can draft and publish organic posts to your Facebook Page.\n');
+    let facebookPageToken = existingConfig.facebookPageToken || '';
+    let facebookPageId = existingConfig.facebookPageId || '';
+    const { connectFacebookPage } = await enquirer.prompt({
+        type: 'confirm',
+        name: 'connectFacebookPage',
+        message: 'Connect a Facebook Page for organic posting?',
+        initial: existingConfig.facebookPageToken ? true : false
+    });
+    if (connectFacebookPage) {
+        const { fbAction } = await enquirer.prompt({
+            type: 'select',
+            name: 'fbAction',
+            message: 'How would you like to proceed?',
+            choices: [
+                { name: 'guide', message: 'Open Graph API Explorer (get a Page Access Token)' },
+                { name: 'skip', message: 'Skip (I already have my token and Page ID)' }
+            ]
+        });
+        if (fbAction === 'guide') {
+            await open('https://developers.facebook.com/tools/explorer/');
+            console.log(chalk.cyan('\nInstructions to get a Facebook Page Access Token:'));
+            console.log(chalk.gray('1. In Graph API Explorer, select your App.'));
+            console.log(chalk.gray('2. Click Generate Access Token and grant pages_manage_posts + pages_read_engagement.'));
+            console.log(chalk.gray('3. Run GET /me/accounts — find your Page and copy its access_token and id.\n'));
+        }
+        let fbVerified = false;
+        while (!fbVerified) {
+            const fbAnswers = await enquirer.prompt([
+                {
+                    type: 'password',
+                    name: 'facebookPageToken',
+                    message: 'Paste your Facebook Page Access Token:',
+                    initial: existingConfig.facebookPageToken || '',
+                    validate: (v) => v.trim() ? true : 'Token cannot be empty.'
+                },
+                {
+                    type: 'input',
+                    name: 'facebookPageId',
+                    message: 'Paste your Facebook Page ID (numeric):',
+                    initial: existingConfig.facebookPageId || '',
+                    validate: (v) => v.trim() ? true : 'Page ID cannot be empty.'
+                }
+            ]);
+            facebookPageToken = fbAnswers.facebookPageToken;
+            facebookPageId = fbAnswers.facebookPageId;
+            console.log(chalk.cyan('Verifying Facebook Page token...'));
+            try {
+                const res = await fetch(`https://graph.facebook.com/v21.0/${facebookPageId}?fields=name,fan_count&access_token=${facebookPageToken}`);
+                const data = await res.json();
+                if (res.ok && data.name) {
+                    console.log(chalk.green(`\n✓ Connected to Facebook Page: "${data.name}" (${(data.fan_count || 0).toLocaleString()} followers)\n`));
+                    fbVerified = true;
+                }
+                else {
+                    console.log(chalk.red(`\n🛑 Verification failed: ${data.error?.message || 'Invalid token or page ID'}\n`));
+                    const { retryAction } = await enquirer.prompt({
+                        type: 'select', name: 'retryAction', message: 'How would you like to handle this?',
+                        choices: [
+                            { name: 'retry', message: 'Try again' },
+                            { name: 'keep', message: 'Keep anyway' },
+                            { name: 'skip', message: 'Skip Facebook Page connection' }
+                        ]
+                    });
+                    if (retryAction === 'keep')
+                        fbVerified = true;
+                    else if (retryAction === 'skip') {
+                        facebookPageToken = '';
+                        facebookPageId = '';
+                        break;
+                    }
+                }
+            }
+            catch (e) {
+                console.log(chalk.red(`\n🛑 Network error: ${e.message}\n`));
+                facebookPageToken = '';
+                facebookPageId = '';
+                break;
+            }
+        }
+        if (facebookPageToken) {
+            console.log(chalk.green('✓ Facebook organic posting module enabled.\n'));
+        }
+        else {
+            console.log(chalk.yellow('✓ Facebook Page connection skipped.\n'));
+        }
+    }
+    console.log(chalk.gray('─────────────────────────────────────────\n'));
+    console.log(chalk.cyan('Step 7/7: Tell me about your business\n'));
     const { productContext } = await enquirer.prompt({
         type: 'input',
         name: 'productContext',
@@ -398,10 +527,13 @@ export async function runSetup() {
         provider: finalModel,
         apiKey,
         localBaseUrl,
+        tier: selectedTier,
         mode,
         connectGoogle,
         metaToken,
-        productContext
+        productContext,
+        facebookPageToken,
+        facebookPageId,
     };
     fs.writeFileSync(path.join(configDir, 'openads.config.json'), JSON.stringify(config, null, 2));
     console.log('You\'re ready. Here are some things to try:\n');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openads-ai",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Open-source AI command center for digital marketers. Audit campaigns, write ad copy, and build strategies — from your terminal.",
   "main": "dist/cli.js",
   "bin": {