feedbackbasket-cli 0.9.3 → 0.11.0

package/README.md

@@ -39,6 +39,7 @@ feedbackbasket feedback list --category BUG --agent
 feedbackbasket feedback create "Login button is broken" --content "Clicking Log in does nothing in Safari." --project myapp --type bug --agent
 feedbackbasket feedback update <id> --status PLANNED --agent
 feedbackbasket widget script myproject --agent
+feedbackbasket mobile setup myproject --bundle-id com.example.app --include-publishable-key --agent
 ```
 
 When installing or configuring a widget for the current app, agents should not rely on the CLI default project. First run `feedbackbasket projects list --agent`, match the current app by its real website URL or clearly matching project name, and only create a new project after confirming no existing project belongs to this app. If the only known URL is `localhost`, ask for the production, staging, preview, or intended public URL before creating the project.
@@ -100,6 +101,7 @@ feedbackbasket feedback update <id> --status PLANNED       # Update status
 feedbackbasket feedback update <id> --category BUG         # Update category
 feedbackbasket feedback reply <id> "Thanks!" --delivery email --reply-to support@example.com
 feedbackbasket feedback reply <id> "Thanks!" --delivery widget
+feedbackbasket feedback reply <id> "Thanks!" --delivery in-app
 feedbackbasket feedback reply <id> "Thanks!" --delivery both --reply-to support@example.com
 feedbackbasket feedback replies <id>                       # List sent replies
 feedbackbasket feedback note <id> "Investigating this..."  # Add internal note
@@ -129,12 +131,15 @@ feedbackbasket bugs stats --project myapp   # Per-project stats
 feedbackbasket widget settings myapp
 
 # Update widget configuration
+feedbackbasket widget settings myapp --capture-mode waitlist
+feedbackbasket widget settings myapp --capture-mode feedback
 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
 feedbackbasket widget settings myapp --email-read-only --hide-email-when-prefilled
+feedbackbasket widget settings myapp --error-tracking --allow-console-errors
 
 # Configure guided feedback types and follow-up questions
 feedbackbasket widget flow myapp
@@ -146,6 +151,19 @@ feedbackbasket widget flow myapp --config ./feedback-flow.json
 feedbackbasket widget script myapp
 ```
 
+Waitlist mode uses the same project script. Add `data-feedbackbasket-waitlist` to your own form, with a required `email` field and optional `name` field. The CLI's `widget script` output shows a starter form when waitlist mode is active.
+
+### Waitlist
+
+```bash
+feedbackbasket waitlist list myapp
+feedbackbasket waitlist list myapp --search "@example.com" --limit 50 --offset 0
+feedbackbasket waitlist list myapp --agent
+feedbackbasket waitlist export myapp
+```
+
+Waitlist listing returns emails, optional names, source pages, total counts, the active capture mode, and pagination. Export prints the dashboard-compatible CSV to stdout.
+
 For inline trigger mode, load the widget once and call the public API from your own button:
 
 ```html
@@ -156,6 +174,8 @@ For inline trigger mode, load the widget once and call the public API from your
 
 Passing the trigger element lets popup mode open beside your custom button. Calling `window.FeedbackWidget.openFeedbackForm()` with no arguments still uses the configured widget position.
 
+Use only the public `openFeedbackForm()` API from the snippet. Do not call internal or undocumented methods such as `open()` or `openModal()`.
+
 Use `--email-read-only` and `--hide-email-when-prefilled` with runtime `userEmail` values from your app. These settings do not store visitor emails in FeedbackBasket widget settings.
 
 The default widget experience is a basic modal. Only switch to popup mode or enable guided feedback when you intentionally want that flow.
@@ -184,6 +204,34 @@ The default widget experience is a basic modal. Only switch to popup mode or ena
 }
 ```
 
+### Mobile Apps
+
+Mobile setup is additive and does not change the website widget. The `fb_mobile_` value is a publishable, write-only project identifier designed to ship in an app; it is not a CLI token or private API key. Mobile commands mask it unless `--include-publishable-key` is explicitly supplied.
+
+```bash
+# Enable mobile feedback and add allowed iOS bundle IDs
+feedbackbasket mobile setup myapp --bundle-id com.example.app
+
+# Return the publishable key and hosted form URL for an authorized app setup
+feedbackbasket mobile setup myapp --bundle-id com.example.app --include-publishable-key --agent
+
+# Inspect and verify the SDK heartbeat
+feedbackbasket mobile status myapp
+feedbackbasket mobile verify myapp --bundle-id com.example.app --wait 120
+
+# Add or remove bundle IDs without replacing the others
+feedbackbasket mobile bundle-ids myapp --add com.example.app.beta
+feedbackbasket mobile bundle-ids myapp --remove com.example.app.beta
+
+# Actions that can interrupt installed apps require explicit confirmation
+feedbackbasket mobile disable myapp --yes
+feedbackbasket mobile rotate-key myapp --yes --include-publishable-key
+```
+
+Agents should never repeat the full publishable key in their final response. They must never place `fb_cli_` or `fb_key_` credentials in a mobile app. Key rotation invalidates the previous key and therefore requires explicit user authorization.
+
+The native Swift SDK securely stores reply-thread credentials in the app Keychain and shows team replies in the same feedback sheet. Host apps do not need to build an inbox or manage reply tokens. Hosted-form integrations remain email-only.
+
 ### Team
 
 ```bash

package/dist/src/cli.js

@@ -11,6 +11,8 @@ import { createDoctorCommand } from './commands/doctor.js';
 import { createSetupCommand } from './commands/setup.js';
 import { createWidgetCommand } from './commands/widget.js';
 import { createTeamCommand } from './commands/team.js';
+import { createWaitlistCommand } from './commands/waitlist.js';
+import { createMobileCommand } from './commands/mobile.js';
 import { renderRootHelp } from './help.js';
 let writer;
 function resolveFormat(opts) {
@@ -62,6 +64,8 @@ export function run() {
     program.addCommand(createFeedbackCommand(getWriter));
     program.addCommand(createBugsCommand(getWriter));
     program.addCommand(createWidgetCommand(getWriter));
+    program.addCommand(createWaitlistCommand(getWriter));
+    program.addCommand(createMobileCommand(getWriter));
     program.addCommand(createTeamCommand(getWriter));
     program.addCommand(createDoctorCommand(getWriter));
     program.addCommand(createSetupCommand(getWriter));

package/dist/src/client.d.ts

@@ -1,6 +1,7 @@
-import type { ProjectsResponse, FeedbackResponse, BugReportsResponse, FeedbackParams, FeedbackCreateInput, FeedbackCreateResponse, FeedbackReplyResponse, BugReportParams, UserProfile, Project, Feedback, WidgetSettings } from './types.js';
+import type { ProjectsResponse, FeedbackResponse, BugReportsResponse, FeedbackParams, FeedbackCreateInput, FeedbackCreateResponse, FeedbackReplyResponse, BugReportParams, UserProfile, Project, Feedback, WidgetSettings, WaitlistResponse, MobileIntegrationResponse } from './types.js';
 export declare class FeedbackBasketClient {
-    private http;
+    private readonly apiBaseUrl;
+    private readonly token;
     constructor(token: string, baseUrl: string);
     me(): Promise<UserProfile>;
     listProjects(): Promise<ProjectsResponse>;
@@ -48,9 +49,23 @@ export declare class FeedbackBasketClient {
     getWidgetScript(projectId: string): Promise<{
         projectId: string;
         projectName: string;
+        captureMode: 'feedback' | 'waitlist';
         embedCode: string;
         scriptUrl: string;
     }>;
+    getMobileIntegration(projectId: string, includePublishableKey?: boolean): Promise<MobileIntegrationResponse>;
+    updateMobileIntegration(projectId: string, data: {
+        enabled?: boolean;
+        addBundleIds?: string[];
+        removeBundleIds?: string[];
+    }, includePublishableKey?: boolean): Promise<MobileIntegrationResponse>;
+    rotateMobileProjectKey(projectId: string, includePublishableKey?: boolean): Promise<MobileIntegrationResponse>;
+    getWaitlist(projectId: string, params?: {
+        search?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<WaitlistResponse>;
+    exportWaitlist(projectId: string): Promise<string>;
     updateFeedback(id: string, data: {
         status?: string;
         category?: string;
@@ -118,5 +133,4 @@ export declare class FeedbackBasketClient {
         email: string;
     }>;
     private request;
-    private handleError;
 }

package/dist/src/client.js

@@ -1,18 +1,11 @@
-import axios, { AxiosError } from 'axios';
 import { USER_AGENT } from './version.js';
-import { errAuth, errForbidden, errRateLimit, errNetwork, errAPI } from './output/errors.js';
+import { CLIError, errAuth, errForbidden, errRateLimit, errNetwork, errAPI } from './output/errors.js';
 export class FeedbackBasketClient {
-    http;
+    apiBaseUrl;
+    token;
     constructor(token, baseUrl) {
-        this.http = axios.create({
-            baseURL: `${baseUrl}/api/v1`,
-            timeout: 30_000,
-            headers: {
-                'Authorization': `Bearer ${token}`,
-                'Content-Type': 'application/json',
-                'User-Agent': USER_AGENT,
-            },
-        });
+        this.apiBaseUrl = `${baseUrl.replace(/\/$/, '')}/api/v1`;
+        this.token = token;
     }
     async me() {
         return this.request('GET', '/auth/me');
@@ -63,6 +56,27 @@ export class FeedbackBasketClient {
     async getWidgetScript(projectId) {
         return this.request('GET', `/projects/${encodeURIComponent(projectId)}/widget-script`);
     }
+    // Mobile feedback
+    async getMobileIntegration(projectId, includePublishableKey = false) {
+        const query = includePublishableKey ? '?includePublishableKey=true' : '';
+        return this.request('GET', `/projects/${encodeURIComponent(projectId)}/mobile${query}`);
+    }
+    async updateMobileIntegration(projectId, data, includePublishableKey = false) {
+        const query = includePublishableKey ? '?includePublishableKey=true' : '';
+        return this.request('PATCH', `/projects/${encodeURIComponent(projectId)}/mobile${query}`, data);
+    }
+    async rotateMobileProjectKey(projectId, includePublishableKey = false) {
+        const query = includePublishableKey ? '?includePublishableKey=true' : '';
+        return this.request('POST', `/projects/${encodeURIComponent(projectId)}/mobile/rotate-key${query}`);
+    }
+    async getWaitlist(projectId, params = {}) {
+        const query = buildQuery(params);
+        return this.request('GET', `/projects/${encodeURIComponent(projectId)}/waitlist${query}`);
+    }
+    async exportWaitlist(projectId) {
+        const data = await this.request('GET', `/projects/${encodeURIComponent(projectId)}/waitlist/export`);
+        return typeof data === 'string' ? data : JSON.stringify(data, null, 2);
+    }
     // Write operations
     async updateFeedback(id, data) {
         return this.request('PATCH', `/feedback/${encodeURIComponent(id)}`, data);
@@ -95,8 +109,8 @@ export class FeedbackBasketClient {
         return this.request('DELETE', `/feedback/${encodeURIComponent(feedbackId)}/notes/${encodeURIComponent(noteId)}`);
     }
     async exportFeedback(projectId, format = 'csv') {
-        const response = await this.http.get(`/projects/${encodeURIComponent(projectId)}/export?format=${format}`);
-        return typeof response.data === 'string' ? response.data : JSON.stringify(response.data, null, 2);
+        const data = await this.request('GET', `/projects/${encodeURIComponent(projectId)}/export?format=${format}`);
+        return typeof data === 'string' ? data : JSON.stringify(data, null, 2);
     }
     // Team
     async listTeam() {
@@ -109,34 +123,58 @@ export class FeedbackBasketClient {
         return this.request('DELETE', `/team/${encodeURIComponent(memberId)}`);
     }
     async request(method, path, data) {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 30_000);
         try {
-            const response = await this.http.request({ method, url: path, data });
-            return response.data;
+            const response = await fetch(`${this.apiBaseUrl}${path}`, {
+                method,
+                signal: controller.signal,
+                headers: {
+                    'Authorization': `Bearer ${this.token}`,
+                    'Content-Type': 'application/json',
+                    'User-Agent': USER_AGENT,
+                },
+                body: data === undefined ? undefined : JSON.stringify(data),
+            });
+            const contentType = response.headers.get('content-type') ?? '';
+            const payload = contentType.includes('application/json')
+                ? await response.json().catch(() => null)
+                : await response.text();
+            if (!response.ok) {
+                const message = getErrorMessage(payload, response.statusText);
+                switch (response.status) {
+                    case 401: throw errAuth(message);
+                    case 403: throw errForbidden(message);
+                    case 404: throw errAPI(404, message);
+                    case 429: throw errRateLimit();
+                    default: throw errAPI(response.status, message);
+                }
+            }
+            return payload;
         }
         catch (error) {
-            throw this.handleError(error);
+            if (error instanceof CLIError)
+                throw error;
+            const cause = error instanceof Error ? error : new Error(String(error));
+            throw errNetwork(cause);
         }
-    }
-    handleError(error) {
-        if (error instanceof AxiosError) {
-            const status = error.response?.status;
-            const message = error.response?.data?.error
-                ?? error.response?.data?.message
-                ?? error.message;
-            if (!error.response) {
-                return errNetwork(error);
-            }
-            switch (status) {
-                case 401: return errAuth(message);
-                case 403: return errForbidden(message);
-                case 404: return errAPI(404, message);
-                case 429: return errRateLimit();
-                default: return errAPI(status ?? 500, message);
-            }
+        finally {
+            clearTimeout(timeout);
         }
-        return error instanceof Error ? error : new Error(String(error));
     }
 }
+function getErrorMessage(payload, fallback) {
+    if (payload && typeof payload === 'object') {
+        const value = payload;
+        if (typeof value.error === 'string')
+            return value.error;
+        if (typeof value.message === 'string')
+            return value.message;
+    }
+    if (typeof payload === 'string' && payload.trim())
+        return payload;
+    return fallback || 'Request failed';
+}
 function buildQuery(params) {
     const parts = [];
     for (const [key, value] of Object.entries(params)) {

package/dist/src/commands/feedback-reply.d.ts

@@ -1,4 +1,6 @@
 import { Command } from 'commander';
 import type { OutputWriter } from '../output/writer.js';
+import type { ReplyDelivery } from '../types.js';
 export declare function createFeedbackReplyCommand(getWriter: () => OutputWriter): Command;
 export declare function createFeedbackRepliesCommand(getWriter: () => OutputWriter): Command;
+export declare function replyDestinations(delivery: ReplyDelivery): Array<'email' | 'widget'>;

package/dist/src/commands/feedback-reply.js

@@ -5,14 +5,14 @@ import { loadConfig } from '../config/config.js';
 import { errAuth, errUsage } from '../output/errors.js';
 import { brand } from '../output/theme.js';
 import { ask } from '../prompt.js';
-const deliveryOptions = new Set(['email', 'widget', 'both']);
+const deliveryOptions = new Set(['email', 'widget', 'in-app', 'both']);
 export function createFeedbackReplyCommand(getWriter) {
     return new Command('reply')
         .argument('<id>', 'Feedback ID to reply to')
         .argument('[content]', 'Reply content (or use --content)')
-        .description('Reply to feedback by email, widget thread, or both')
+        .description('Reply to feedback by email, widget/in-app thread, or both')
         .option('--content <text>', 'Reply content (alternative to positional argument)')
-        .option('--delivery <delivery>', 'Reply delivery (email, widget, both)', 'email')
+        .option('--delivery <delivery>', 'Reply delivery (email, widget, in-app, both)', 'email')
         .option('--reply-to <email>', 'Reply-to email for email delivery')
         .action(async (id, contentArg, opts) => {
         const writer = getWriter();
@@ -22,19 +22,22 @@ export function createFeedbackReplyCommand(getWriter) {
             throw errUsage('Reply content is required', 'Example: feedbackbasket feedback reply <id> "Thanks for reporting this!" --delivery widget');
         }
         if (!deliveryOptions.has(delivery)) {
-            throw errUsage('Delivery must be email, widget, or both', 'Example: feedbackbasket feedback reply <id> "Thanks!" --delivery both --reply-to support@example.com');
+            throw errUsage('Delivery must be email, widget, in-app, or both', 'Example: feedbackbasket feedback reply <id> "Thanks!" --delivery both --reply-to support@example.com');
         }
         const client = requireClient();
         const feedback = await client.getFeedbackById(id);
-        const destinations = delivery === 'both'
-            ? ['email', 'widget']
-            : [delivery];
+        if (delivery === 'in-app' && feedback.replyChannel !== 'in_app') {
+            throw errUsage('This feedback does not have an in-app reply thread.', 'Use --delivery widget for website-widget feedback or --delivery email when an email address is available.');
+        }
+        const destinations = replyDestinations(delivery);
         const sendsEmail = destinations.includes('email');
         const sendsWidget = destinations.includes('widget');
         let replyTo = opts.replyTo ?? feedback.project.replyToEmail ?? undefined;
         if (sendsEmail) {
             if (!feedback.email) {
-                throw errUsage('This feedback has no email address; use --delivery widget if it has a widget thread.');
+                throw errUsage(feedback.replyChannel === 'in_app'
+                    ? 'This feedback has no email address; use --delivery in-app.'
+                    : 'This feedback has no email address; use --delivery widget if it has a widget thread.');
             }
             if (!replyTo) {
                 const isInteractive = !writer.isMachineOutput() && process.stdin.isTTY;
@@ -56,7 +59,7 @@ export function createFeedbackReplyCommand(getWriter) {
             }
         }
         if (sendsWidget && !feedback.hasWidgetAccess) {
-            throw errUsage('This feedback is not connected to a widget thread.', 'Use --delivery email for feedback with an email address, or ask the human how they want to respond.');
+            throw errUsage('This feedback has no in-app or widget reply thread.', 'Use --delivery email for feedback with an email address, or ask the human how they want to respond.');
         }
         const result = await client.sendReply(id, content, {
             replyToEmail: replyTo,
@@ -71,16 +74,16 @@ export function createFeedbackReplyCommand(getWriter) {
                 }
             }
             if (result.message) {
-                console.log(`  ${brand.success('[OK]')} Widget reply posted`);
+                console.log(`  ${brand.success('[OK]')} ${feedback.replyChannel === 'in_app' ? 'In-app' : 'Widget'} reply posted`);
                 console.log(`    ${brand.muted('By:')}   ${result.message.sentByName ?? 'CLI'}`);
             }
             console.log();
         }
         writer.ok(result, {
             summary: delivery === 'both'
-                ? 'Reply sent by email and widget'
-                : delivery === 'widget'
-                    ? 'Widget reply posted'
+                ? `Reply sent by email and ${feedback.replyChannel === 'in_app' ? 'in-app' : 'widget'}`
+                : sendsWidget
+                    ? `${feedback.replyChannel === 'in_app' ? 'In-app' : 'Widget'} reply posted`
                     : `Reply sent to ${result.sentTo}`,
             breadcrumbs: [
                 { action: 'View replies', cmd: `feedbackbasket feedback replies ${id}` },
@@ -139,6 +142,13 @@ export function createFeedbackRepliesCommand(getWriter) {
         });
     });
 }
+export function replyDestinations(delivery) {
+    if (delivery === 'both')
+        return ['email', 'widget'];
+    if (delivery === 'in-app')
+        return ['widget'];
+    return [delivery];
+}
 function requireClient() {
     const manager = new AuthManager();
     const token = manager.resolveToken();

package/dist/src/commands/feedback.js

@@ -186,7 +186,7 @@ function renderFeedbackDetail(item) {
         ['OS', item.os],
         ['Device', item.device],
         ['Language', item.language],
-        ['Widget Thread', item.hasWidgetAccess ? 'Yes' : null],
+        ['Reply Channel', item.replyChannel === 'in_app' ? 'In-app' : item.hasWidgetAccess ? 'Widget' : null],
         ['Created', item.createdAt],
     ];
     for (const [label, value] of fields) {

package/dist/src/commands/mobile.d.ts

@@ -0,0 +1,7 @@
+import { Command } from 'commander';
+import type { MobileIntegrationResponse } from '../types.js';
+import type { OutputWriter } from '../output/writer.js';
+export declare function createMobileCommand(getWriter: () => OutputWriter): Command;
+export declare function projectRef(projectArg: string | undefined, projectId: string): string;
+export declare function validateBundleIds(bundleIds: string[]): string[];
+export declare function isMobileConnectionVerified(result: MobileIntegrationResponse, expectedBundleId?: string): boolean;