feedbackbasket-cli 0.4.0 → 0.6.0

package/README.md

@@ -16,7 +16,7 @@ feedbackbasket login
 # Or use a token directly (for CI/headless)
 feedbackbasket login --token fb_cli_your_token_here
 
-# Remote server/headless browser flow (paste token back into terminal)
+# Remote server flow: use when localhost browser callbacks cannot reach the CLI
 feedbackbasket login --manual
 
 # Start exploring
@@ -51,7 +51,7 @@ feedbackbasket setup claude
 
 ```bash
 feedbackbasket login                   # Browser OAuth flow (alias for auth login)
-feedbackbasket login --manual          # Remote/headless browser token paste
+feedbackbasket login --manual          # No localhost browser callback (remote servers)
 feedbackbasket login --token <token>   # Use an existing CLI token (CI / scripts)
 feedbackbasket logout                  # Clear credentials (alias for auth logout)
 feedbackbasket auth status             # Show auth state, scope, default project
@@ -121,11 +121,43 @@ feedbackbasket widget settings myapp
 feedbackbasket widget settings myapp --color "#22c55e" --label "Send Feedback"
 feedbackbasket widget settings myapp --position bottom-left --display modal
 feedbackbasket widget settings myapp --email-required --intro "How can we improve?"
+feedbackbasket widget settings myapp --button-radius 10 --button-size regular
+feedbackbasket widget settings myapp --show-email --allow-attachments --guided
+
+# Configure guided feedback types and follow-up questions
+feedbackbasket widget flow myapp
+feedbackbasket widget flow myapp --enable
+feedbackbasket widget flow myapp --reset-default --enable
+feedbackbasket widget flow myapp --config ./feedback-flow.json
 
 # Get embed code (ready to paste into your HTML)
 feedbackbasket widget script myapp
 ```
 
+`widget flow --config` accepts either a `feedbackFlow` object or a JSON object with a `feedbackFlow` key. V1 supports guided mode with `text`, `textarea`, and `single_choice` follow-up questions.
+
+```json
+{
+  "enabled": true,
+  "mode": "guided",
+  "types": [
+    {
+      "id": "bug",
+      "emoji": "🐞",
+      "label": "Bug report",
+      "description": "Something is broken or not working",
+      "questions": [
+        {
+          "id": "steps",
+          "label": "What steps can reproduce it?",
+          "type": "textarea"
+        }
+      ]
+    }
+  ]
+}
+```
+
 ### Team
 
 ```bash

package/dist/src/auth/login.js

@@ -108,7 +108,8 @@ export async function browserLogin(baseUrl, scope = 'read') {
             console.log(`  ${brand.primary(authorizeUrl)}`);
             console.log();
             console.log(`  ${brand.muted('Waiting for authentication...')}`);
-            console.log(`  ${brand.muted('On remote machines, use: feedbackbasket login --manual')}`);
+            console.log(`  ${brand.muted('If this machine cannot receive the localhost browser callback, use:')}`);
+            console.log(`  ${brand.command('feedbackbasket login --manual')}`);
             console.log();
             open(authorizeUrl).catch(() => {
                 // Browser open failed; user will use the URL manually.
@@ -121,10 +122,13 @@ export async function manualLogin(baseUrl, scope = 'read') {
     console.log();
     console.log(`  ${logo()} CLI`);
     console.log();
-    console.log(`  ${brand.primary('Open this URL to create a CLI token:')}`);
+    console.log(`  ${brand.primary('Open this URL on any machine with a browser:')}`);
     console.log();
     console.log(`  ${brand.primary(authorizeUrl)}`);
     console.log();
+    console.log(`  ${brand.muted('Use this when a remote server cannot receive the localhost browser callback.')}`);
+    console.log(`  ${brand.muted('The CLI still needs outbound HTTPS access to verify and use the token.')}`);
+    console.log();
     console.log(`  ${brand.muted('After approving access, paste the token shown in your browser.')}`);
     console.log();
     open(authorizeUrl).catch(() => {

package/dist/src/client.d.ts

@@ -1,4 +1,4 @@
-import type { ProjectsResponse, FeedbackResponse, BugReportsResponse, FeedbackParams, BugReportParams, UserProfile, Project, Feedback } from './types.js';
+import type { ProjectsResponse, FeedbackResponse, BugReportsResponse, FeedbackParams, BugReportParams, UserProfile, Project, Feedback, WidgetSettings } from './types.js';
 export declare class FeedbackBasketClient {
     private http;
     constructor(token: string, baseUrl: string);
@@ -37,12 +37,12 @@ export declare class FeedbackBasketClient {
     getWidgetSettings(projectId: string): Promise<{
         projectId: string;
         projectName: string;
-        settings: Record<string, unknown>;
+        settings: WidgetSettings;
     }>;
-    updateWidgetSettings(projectId: string, settings: Record<string, unknown>): Promise<{
+    updateWidgetSettings(projectId: string, settings: Partial<WidgetSettings>): Promise<{
         projectId: string;
         projectName: string;
-        settings: Record<string, unknown>;
+        settings: WidgetSettings;
     }>;
     getWidgetScript(projectId: string): Promise<{
         projectId: string;

package/dist/src/commands/auth.js

@@ -18,7 +18,7 @@ export function createAuthCommand(getWriter) {
         .command('login')
         .description('Authenticate with FeedbackBasket')
         .option('--token <token>', 'Use an API token directly (for CI/headless)')
-        .option('--manual', 'Show a browser token to paste back into the terminal')
+        .option('--manual', 'Authenticate without a localhost browser callback')
         .option('--scope <scope>', 'Access scope: read or full', 'full')
         .action(async (opts) => {
         const writer = getWriter();
@@ -299,7 +299,7 @@ export function createLoginCommand(getWriter) {
     return new Command('login')
         .description('Authenticate with FeedbackBasket (alias for auth login)')
         .option('--token <token>', 'Use an API token directly (for CI/headless)')
-        .option('--manual', 'Show a browser token to paste back into the terminal')
+        .option('--manual', 'Authenticate without a localhost browser callback')
         .option('--scope <scope>', 'Access scope: read or full', 'full')
         .action(async (opts) => {
         // Delegate to auth login by re-parsing

package/dist/src/commands/feedback.js

@@ -171,6 +171,7 @@ function renderFeedbackDetail(item) {
     const fields = [
         ['Status', item.status],
         ['Category', item.category],
+        ['Feedback Type', formatFeedbackType(item)],
         ['Sentiment', item.sentiment],
         ['Priority', item.aiPriorityScore != null ? String(item.aiPriorityScore) : null],
         ['Email', item.email],
@@ -190,6 +191,15 @@ function renderFeedbackDetail(item) {
     console.log();
     console.log(brand.bold('Content:'));
     console.log(`  ${item.content}`);
+    if (item.followUpAnswers && item.followUpAnswers.length > 0) {
+        console.log();
+        console.log(brand.bold('Follow-up Answers:'));
+        for (const answer of item.followUpAnswers) {
+            const value = answer.value?.trim() || brand.muted('(skipped)');
+            console.log(`  ${brand.bold(answer.label)}`);
+            console.log(`    ${value}`);
+        }
+    }
     if (item.aiSummary) {
         console.log();
         console.log(brand.bold('AI Summary:'));
@@ -209,3 +219,11 @@ function renderFeedbackDetail(item) {
         }
     }
 }
+function formatFeedbackType(item) {
+    if (!item.feedbackType)
+        return undefined;
+    const label = item.feedbackType.label || item.feedbackType.id;
+    if (!label)
+        return undefined;
+    return item.feedbackType.emoji ? `${item.feedbackType.emoji} ${label}` : label;
+}

package/dist/src/commands/widget.js

@@ -1,10 +1,49 @@
 import { Command } from 'commander';
+import { readFileSync } from 'node:fs';
 import { FeedbackBasketClient } from '../client.js';
 import { AuthManager } from '../auth/manager.js';
 import { loadConfig } from '../config/config.js';
 import { errAuth, errUsage } from '../output/errors.js';
 import { brand, divider } from '../output/theme.js';
 import { resolveProject } from '../resolve.js';
+const DEFAULT_FEEDBACK_FLOW = {
+    enabled: false,
+    mode: 'guided',
+    types: [
+        {
+            id: 'bug',
+            emoji: '🐞',
+            label: 'Bug report',
+            description: 'Something is broken or not working',
+            questions: [
+                { id: 'steps', label: 'What steps can reproduce it?', type: 'textarea', placeholder: 'Tell us what you did before the issue happened.' },
+                { id: 'expected', label: 'What did you expect to happen?', type: 'textarea', placeholder: 'Describe the result you expected.' },
+                { id: 'urgency', label: 'How urgent is this?', type: 'single_choice', options: ['Low', 'Medium', 'High'] },
+            ],
+        },
+        {
+            id: 'feature',
+            emoji: '💡',
+            label: 'Feature request',
+            description: 'Suggest an idea or improvement',
+            questions: [
+                { id: 'problem', label: 'What problem are you trying to solve?', type: 'textarea', placeholder: 'Share the job this feature would help with.' },
+                { id: 'benefit', label: 'Who would benefit from this?', type: 'text', placeholder: 'For example: admins, customers, teammates.' },
+                { id: 'importance', label: 'How important is this?', type: 'single_choice', options: ['Nice to have', 'Important', 'Critical'] },
+            ],
+        },
+        {
+            id: 'general',
+            emoji: '💬',
+            label: 'General feedback',
+            description: 'Share thoughts, praise, or anything else',
+            questions: [
+                { id: 'context', label: 'What made you want to share this?', type: 'textarea', placeholder: 'Add any helpful context.' },
+                { id: 'sentiment', label: 'How are you feeling about it?', type: 'single_choice', options: ['Happy', 'Neutral', 'Frustrated'] },
+            ],
+        },
+    ],
+};
 export function createWidgetCommand(getWriter) {
     const widget = new Command('widget')
         .description('Manage feedback widget');
@@ -14,23 +53,44 @@ export function createWidgetCommand(getWriter) {
         .description('View or update widget settings')
         .option('--color <hex>', 'Button color (e.g. #22c55e)')
         .option('--label <text>', 'Button label')
-        .option('--position <pos>', 'Widget position (bottom-right, bottom-left, top-right, top-left)')
+        .option('--position <pos>', 'Widget position (bottom-right, bottom-left, middle-right-edge, middle-left-edge, bottom-right-edge, bottom-left-edge)')
         .option('--intro <text>', 'Intro message shown in the widget')
         .option('--success <text>', 'Success message after submission')
-        .option('--trigger <mode>', 'Trigger mode (floating, manual)')
-        .option('--display <mode>', 'Display mode (modal, popover)')
+        .option('--trigger <mode>', 'Trigger mode (floating, inline)')
+        .option('--display <mode>', 'Display mode (modal, popup)')
+        .option('--button-radius <px>', 'Button radius in pixels')
+        .option('--button-size <size>', 'Button size (mini, regular)')
+        .option('--icon <value>', 'Icon value (emoji or svg:chat-bubble-bottom-center-text)')
         .option('--email-required', 'Require email from submitters')
         .option('--no-email-required', 'Make email optional')
+        .option('--show-email', 'Show the email field')
+        .option('--no-show-email', 'Hide the email field')
+        .option('--allow-attachments', 'Allow image attachments')
+        .option('--no-allow-attachments', 'Disable image attachments')
         .option('--icon-only', 'Show only the icon, no label')
         .option('--no-icon-only', 'Show both icon and label')
+        .option('--show-icon', 'Show an icon next to the label')
+        .option('--no-show-icon', 'Hide the icon')
+        .option('--show-branding', 'Show FeedbackBasket branding')
+        .option('--no-show-branding', 'Hide FeedbackBasket branding when plan allows it')
+        .option('--z-index <value>', 'Widget z-index')
+        .option('--guided', 'Enable guided feedback types')
+        .option('--disable-guided', 'Disable guided feedback types')
         .action(async (projectArg, opts) => {
         const writer = getWriter();
         const client = requireClient();
         const projectId = await resolveProjectId(client, projectArg);
         const hasUpdates = opts.color || opts.label || opts.position || opts.intro ||
             opts.success || opts.trigger || opts.display ||
-            opts.emailRequired !== undefined || opts.iconOnly !== undefined;
+            opts.buttonRadius || opts.buttonSize || opts.icon ||
+            opts.emailRequired !== undefined || opts.showEmail !== undefined ||
+            opts.allowAttachments !== undefined || opts.iconOnly !== undefined ||
+            opts.showIcon !== undefined || opts.showBranding !== undefined ||
+            opts.zIndex || opts.guided || opts.disableGuided;
         if (hasUpdates) {
+            if (opts.guided && opts.disableGuided) {
+                throw errUsage('Choose either --guided or --disable-guided, not both');
+            }
             // Update mode
             const settings = {};
             if (opts.color)
@@ -47,10 +107,33 @@ export function createWidgetCommand(getWriter) {
                 settings.triggerMode = opts.trigger;
             if (opts.display)
                 settings.displayMode = opts.display;
+            if (opts.buttonRadius)
+                settings.buttonRadius = parseInt(opts.buttonRadius, 10);
+            if (opts.buttonSize)
+                settings.buttonSize = opts.buttonSize;
+            if (opts.icon)
+                settings.icon = opts.icon;
             if (opts.emailRequired !== undefined)
                 settings.emailRequired = opts.emailRequired;
+            if (opts.showEmail !== undefined)
+                settings.showEmailField = opts.showEmail;
+            if (opts.allowAttachments !== undefined)
+                settings.allowAttachments = opts.allowAttachments;
             if (opts.iconOnly !== undefined)
                 settings.iconOnly = opts.iconOnly;
+            if (opts.showIcon !== undefined)
+                settings.showIcon = opts.showIcon;
+            if (opts.showBranding !== undefined)
+                settings.showBranding = opts.showBranding;
+            if (opts.zIndex)
+                settings.zIndex = parseInt(opts.zIndex, 10);
+            if (opts.guided || opts.disableGuided) {
+                const current = await client.getWidgetSettings(projectId);
+                settings.feedbackFlow = {
+                    ...(current.settings.feedbackFlow ?? DEFAULT_FEEDBACK_FLOW),
+                    enabled: Boolean(opts.guided),
+                };
+            }
             const result = await client.updateWidgetSettings(projectId, settings);
             if (!writer.isMachineOutput()) {
                 console.log(`  ${brand.success('✓')} Widget settings updated for ${brand.bold(result.projectName)}`);
@@ -61,6 +144,7 @@ export function createWidgetCommand(getWriter) {
                 breadcrumbs: [
                     { action: 'Get embed code', cmd: `feedbackbasket widget script ${projectId}` },
                     { action: 'View settings', cmd: `feedbackbasket widget settings ${projectId}` },
+                    { action: 'Configure guided questions', cmd: `feedbackbasket widget flow ${projectId} --enable` },
                 ],
             });
         }
@@ -74,10 +158,71 @@ export function createWidgetCommand(getWriter) {
                 summary: `Widget settings for "${result.projectName}"`,
                 breadcrumbs: [
                     { action: 'Update color', cmd: `feedbackbasket widget settings ${projectId} --color "#22c55e"` },
+                    { action: 'Enable guided flow', cmd: `feedbackbasket widget flow ${projectId} --enable` },
+                    { action: 'Get embed code', cmd: `feedbackbasket widget script ${projectId}` },
+                ],
+            });
+        }
+    });
+    // --- widget flow ---
+    widget
+        .command('flow [project]')
+        .description('View or update guided feedback types and follow-up questions')
+        .option('--enable', 'Enable guided feedback flow')
+        .option('--disable', 'Disable guided feedback flow')
+        .option('--reset-default', 'Reset guided flow to the default Bug, Feature, and General templates')
+        .option('--config <path>', 'Path to a JSON file containing a feedbackFlow object')
+        .action(async (projectArg, opts) => {
+        const writer = getWriter();
+        const client = requireClient();
+        const projectId = await resolveProjectId(client, projectArg);
+        const hasUpdates = opts.enable || opts.disable || opts.resetDefault || opts.config;
+        if (hasUpdates) {
+            if (opts.enable && opts.disable) {
+                throw errUsage('Choose either --enable or --disable, not both');
+            }
+            const current = await client.getWidgetSettings(projectId);
+            let feedbackFlow = current.settings.feedbackFlow ?? DEFAULT_FEEDBACK_FLOW;
+            if (opts.resetDefault) {
+                feedbackFlow = cloneDefaultFeedbackFlow();
+            }
+            if (opts.config) {
+                feedbackFlow = parseFeedbackFlowConfig(opts.config);
+            }
+            if (opts.enable)
+                feedbackFlow = { ...feedbackFlow, enabled: true };
+            if (opts.disable)
+                feedbackFlow = { ...feedbackFlow, enabled: false };
+            const result = await client.updateWidgetSettings(projectId, { feedbackFlow });
+            if (!writer.isMachineOutput()) {
+                console.log(`  ${brand.success('✓')} Guided feedback flow updated for ${brand.bold(result.projectName)}`);
+                console.log();
+                renderFeedbackFlow(result.settings.feedbackFlow);
+            }
+            writer.ok(result.settings.feedbackFlow, {
+                summary: `Updated guided feedback flow for "${result.projectName}"`,
+                breadcrumbs: [
+                    { action: 'View widget settings', cmd: `feedbackbasket widget settings ${projectId}` },
                     { action: 'Get embed code', cmd: `feedbackbasket widget script ${projectId}` },
                 ],
             });
+            return;
+        }
+        const result = await client.getWidgetSettings(projectId);
+        if (!writer.isMachineOutput()) {
+            console.log(brand.bold(`Guided feedback flow — ${result.projectName}`));
+            console.log(divider(40));
+            console.log();
+            renderFeedbackFlow(result.settings.feedbackFlow);
         }
+        writer.ok(result.settings.feedbackFlow ?? DEFAULT_FEEDBACK_FLOW, {
+            summary: `Guided feedback flow for "${result.projectName}"`,
+            breadcrumbs: [
+                { action: 'Enable guided flow', cmd: `feedbackbasket widget flow ${projectId} --enable` },
+                { action: 'Reset templates', cmd: `feedbackbasket widget flow ${projectId} --reset-default --enable` },
+                { action: 'Apply JSON config', cmd: `feedbackbasket widget flow ${projectId} --config ./feedback-flow.json` },
+            ],
+        });
     });
     // --- widget script ---
     widget
@@ -127,6 +272,66 @@ async function resolveProjectId(client, projectArg) {
         return config.defaultProject;
     throw errUsage('Project is required. Pass a project name/ID or set a default.', 'feedbackbasket widget settings <project> or feedbackbasket config set defaultProject <id>');
 }
+function cloneDefaultFeedbackFlow() {
+    return JSON.parse(JSON.stringify(DEFAULT_FEEDBACK_FLOW));
+}
+function parseFeedbackFlowConfig(path) {
+    const raw = readFileSync(path, 'utf8');
+    const parsed = JSON.parse(raw);
+    const candidate = isRecord(parsed) && isRecord(parsed.feedbackFlow)
+        ? parsed.feedbackFlow
+        : parsed;
+    if (!isRecord(candidate) || !Array.isArray(candidate.types)) {
+        throw errUsage('Feedback flow config must be a feedbackFlow object with a types array');
+    }
+    return {
+        enabled: typeof candidate.enabled === 'boolean' ? candidate.enabled : true,
+        mode: 'guided',
+        types: candidate.types.map((type, index) => {
+            if (!isRecord(type))
+                throw errUsage(`Feedback type at index ${index} must be an object`);
+            const id = stringValue(type.id) || `type-${index + 1}`;
+            const label = stringValue(type.label);
+            if (!label)
+                throw errUsage(`Feedback type "${id}" is missing label`);
+            return {
+                id,
+                emoji: stringValue(type.emoji) || '💬',
+                label,
+                description: stringValue(type.description),
+                questions: Array.isArray(type.questions)
+                    ? type.questions.map((question, qIndex) => {
+                        if (!isRecord(question))
+                            throw errUsage(`Question ${qIndex + 1} in "${id}" must be an object`);
+                        const questionId = stringValue(question.id) || `question-${qIndex + 1}`;
+                        const questionLabel = stringValue(question.label);
+                        const questionType = stringValue(question.type);
+                        if (!questionLabel)
+                            throw errUsage(`Question "${questionId}" in "${id}" is missing label`);
+                        if (!['text', 'textarea', 'single_choice'].includes(questionType)) {
+                            throw errUsage(`Question "${questionId}" type must be text, textarea, or single_choice`);
+                        }
+                        return {
+                            id: questionId,
+                            label: questionLabel,
+                            type: questionType,
+                            placeholder: stringValue(question.placeholder) || undefined,
+                            options: Array.isArray(question.options)
+                                ? question.options.map(String).filter(Boolean)
+                                : undefined,
+                        };
+                    })
+                    : [],
+            };
+        }),
+    };
+}
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function stringValue(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
 function renderWidgetSettings(projectName, settings) {
     console.log(brand.bold(`Widget settings — ${projectName}`));
     console.log(divider(40));
@@ -135,12 +340,17 @@ function renderWidgetSettings(projectName, settings) {
         ['Button Color', String(settings.buttonColor ?? '')],
         ['Button Label', String(settings.buttonLabel ?? '')],
         ['Button Radius', String(settings.buttonRadius ?? '')],
+        ['Button Size', String(settings.buttonSize ?? '')],
+        ['Icon', String(settings.icon ?? '')],
         ['Icon Only', String(settings.iconOnly ?? false)],
         ['Show Icon', String(settings.showIcon ?? true)],
         ['Position', String(settings.position ?? '')],
         ['Trigger Mode', String(settings.triggerMode ?? '')],
         ['Display Mode', String(settings.displayMode ?? '')],
+        ['Show Email', String(settings.showEmailField ?? true)],
         ['Email Required', String(settings.emailRequired ?? false)],
+        ['Attachments', String(settings.allowAttachments ?? true)],
+        ['Guided Flow', String(settings.feedbackFlow?.enabled ?? false)],
         ['Intro Message', String(settings.introMessage ?? '')],
         ['Success Message', String(settings.successMessage ?? '')],
         ['Z-Index', String(settings.zIndex ?? '')],
@@ -150,4 +360,35 @@ function renderWidgetSettings(projectName, settings) {
         console.log(`  ${brand.label(label.padEnd(18))} ${value}`);
     }
     console.log();
+    if (settings.feedbackFlow?.enabled) {
+        renderFeedbackFlow(settings.feedbackFlow);
+    }
+}
+function renderFeedbackFlow(flow) {
+    const feedbackFlow = flow ?? DEFAULT_FEEDBACK_FLOW;
+    console.log(`  ${brand.label('Enabled'.padEnd(18))} ${feedbackFlow.enabled}`);
+    console.log(`  ${brand.label('Mode'.padEnd(18))} ${feedbackFlow.mode}`);
+    console.log();
+    if (feedbackFlow.types.length === 0) {
+        console.log(`  ${brand.muted('No feedback types configured')}`);
+        console.log();
+        return;
+    }
+    for (const type of feedbackFlow.types) {
+        const heading = `${type.emoji ? `${type.emoji} ` : ''}${type.label} (${type.id})`;
+        console.log(`  ${brand.bold(heading)}`);
+        if (type.description) {
+            console.log(`    ${brand.muted(type.description)}`);
+        }
+        if (type.questions.length === 0) {
+            console.log(`    ${brand.muted('No follow-up questions')}`);
+        }
+        else {
+            for (const question of type.questions) {
+                const options = question.options?.length ? ` [${question.options.join(', ')}]` : '';
+                console.log(`    - ${question.label} ${brand.muted(`(${question.type})${options}`)}`);
+            }
+        }
+        console.log();
+    }
 }

package/dist/src/help.js

@@ -60,6 +60,7 @@ export function renderRootHelp() {
     lines.push(`${INDENT}${brand.muted('$')} feedbackbasket feedback list --category BUG --status OPEN`);
     lines.push(`${INDENT}${brand.muted('$')} feedbackbasket bugs list --severity high`);
     lines.push(`${INDENT}${brand.muted('$')} feedbackbasket widget script myapp`);
+    lines.push(`${INDENT}${brand.muted('$')} feedbackbasket widget flow myapp --reset-default --enable`);
     lines.push(`${INDENT}${brand.muted('$')} feedbackbasket projects create "My App" --url https://myapp.com`);
     lines.push('');
     // Learn More

package/dist/src/types.d.ts

@@ -2,6 +2,47 @@ export type FeedbackStatus = 'OPEN' | 'UNDER_REVIEW' | 'PLANNED' | 'IN_PROGRESS'
 export type FeedbackCategory = 'BUG' | 'FEATURE_REQUEST' | 'IMPROVEMENT' | 'QUESTION';
 export type Sentiment = 'POSITIVE' | 'NEGATIVE' | 'NEUTRAL';
 export type Severity = 'high' | 'medium' | 'low';
+export type FeedbackFlowQuestionType = 'text' | 'textarea' | 'single_choice';
+export interface FeedbackFlowQuestion {
+    id: string;
+    label: string;
+    type: FeedbackFlowQuestionType;
+    placeholder?: string;
+    options?: string[];
+}
+export interface FeedbackFlowType {
+    id: string;
+    emoji: string;
+    label: string;
+    description: string;
+    questions: FeedbackFlowQuestion[];
+}
+export interface FeedbackFlowSettings {
+    enabled: boolean;
+    mode: 'guided';
+    types: FeedbackFlowType[];
+}
+export interface WidgetSettings {
+    widgetType?: string;
+    triggerMode?: 'floating' | 'inline';
+    buttonColor?: string;
+    buttonRadius?: number;
+    buttonLabel?: string;
+    buttonSize?: 'mini' | 'regular';
+    iconOnly?: boolean;
+    showIcon?: boolean;
+    icon?: string;
+    introMessage?: string;
+    successMessage?: string;
+    position?: string;
+    showEmailField?: boolean;
+    emailRequired?: boolean;
+    allowAttachments?: boolean;
+    displayMode?: 'modal' | 'popup';
+    zIndex?: number;
+    showBranding?: boolean;
+    feedbackFlow?: FeedbackFlowSettings;
+}
 export interface Project {
     id: string;
     name: string;
@@ -23,6 +64,18 @@ export interface Feedback {
     aiSummary?: string | null;
     aiPriorityScore?: number | null;
     reasoning?: string | null;
+    feedbackType?: {
+        id?: string;
+        emoji?: string;
+        label?: string;
+        description?: string;
+    } | null;
+    followUpAnswers?: Array<{
+        questionId: string;
+        label: string;
+        type: FeedbackFlowQuestionType;
+        value: string;
+    }> | null;
     pageUrl?: string | null;
     browser?: string | null;
     os?: string | null;

package/dist/src/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.4.0";
-export declare const USER_AGENT = "FeedbackBasket-CLI/0.4.0";
+export declare const VERSION = "0.6.0";
+export declare const USER_AGENT = "FeedbackBasket-CLI/0.6.0";

package/dist/src/version.js

@@ -1,2 +1,2 @@
-export const VERSION = '0.4.0';
+export const VERSION = '0.6.0';
 export const USER_AGENT = `FeedbackBasket-CLI/${VERSION}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "feedbackbasket-cli",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Command-line interface for FeedbackBasket — manage feedback from your terminal",
   "type": "module",
   "main": "dist/src/cli.js",

package/skills/feedbackbasket/SKILL.md

@@ -21,7 +21,7 @@ Full command-line interface for managing feedback, bug reports, projects, widget
 
 ```bash
 feedbackbasket login                   # Opens browser — one click, full access
-feedbackbasket login --manual          # Remote/headless browser token paste
+feedbackbasket login --manual          # No localhost browser callback (remote servers)
 feedbackbasket login --token <TOKEN>   # Manual token (CI/headless)
 feedbackbasket auth status             # Check auth state
 feedbackbasket doctor                  # Full diagnostics
@@ -96,8 +96,17 @@ feedbackbasket widget settings <project>
 feedbackbasket widget settings <project> --color "#22c55e" --label "Send Feedback"
 feedbackbasket widget settings <project> --position bottom-left --display modal
 feedbackbasket widget settings <project> --email-required --intro "How can we improve?"
+feedbackbasket widget settings <project> --show-email --allow-attachments --guided
+
+# Guided feedback types and follow-up questions
+feedbackbasket widget flow <project>
+feedbackbasket widget flow <project> --enable
+feedbackbasket widget flow <project> --reset-default --enable
+feedbackbasket widget flow <project> --config ./feedback-flow.json
 ```
 
+`widget flow --config` accepts either a `feedbackFlow` object or a JSON object with a `feedbackFlow` key. Use it when an agent needs to customize visitor choices such as Bug report, Feature request, and General feedback. Supported v1 question types are `text`, `textarea`, and `single_choice`.
+
 ### Team
 ```bash
 feedbackbasket team list
@@ -119,6 +128,8 @@ feedbackbasket projects create "My App" --url https://myapp.com --agent
 feedbackbasket widget script "My App" --agent
 # Agent gets the embed code, adds it to the HTML
 feedbackbasket widget settings "My App" --color "#22c55e" --label "Feedback" --agent
+# Optional: enable the guided wizard with Bug, Feature, and General templates
+feedbackbasket widget flow "My App" --reset-default --enable --agent
 ```
 
 ### Triage new feedback
@@ -133,7 +144,7 @@ feedbackbasket feedback note <id> "Reviewing — appears related to auth flow" -
 ```bash
 feedbackbasket bugs list --severity high --agent
 feedbackbasket feedback show <id> --agent
-# Response includes browser, OS, page URL, AI analysis, priority score
+# Response includes browser, OS, page URL, submitted feedback type, follow-up answers, AI analysis, priority score
 ```
 
 ### Close the loop — reply to the submitter