Built by Jared

What’s better than AI answers? Streaming AI answers.

Streaming means responses from OpenAI come in piece by piece. So users can start reading answers before the whole thing is complete. In addition to feeling faster, it also feels cool 😎

We're starting to roll out Audiences.

Audiences let you control who sees your nudges, Questlists, and commands. We're working to bring more compatibility for audiences to all of our widgets, but right now, it's available in nudges and questlists, with commands coming soon. Eventually, the Audiences tab will absorb the existing "Rules" tab so that you can use the same component across all of your widgets to target different subsets of users for different things.

Got any other ideas for audiences we should have built in? Let us know!

We now highlight the tabs in the Bar that have search results, and if there are no results in the current tab, suggest the other tabs which do.

This makes for a better tabs user experience. Users are now directed to the best tabs for their search query.

For example, if they're looking for some information in the Videos tab, but there's only an article in the Help tab, they'll know to go to that to find what they're looking for.

This will automatically turn on for all accounts — no update is required on your end. Just make sure you have tabs enabled for some categories to see the new behavior.

Previously, CommandBar's inline bar wasn't bootable within the shadow DOM, and themes would not apply correctly. Now the inline bar is fully bootable within the shadow DOM, ensuring proper functionality and theme compatibility.

The update also includes improvements to the CSS structure to enhance compatibility with other web frameworks (e.g., StencilJS, which uses the shadow DOM), making integrating with other applications and frameworks easier. Overall, this update provides a more seamless and efficient user experience when working with CommandBar's inline bar.

Previously, we bundled all dependencies in our self-hosted @commandbar/foobar NPM package. The dependencies are now separate, allowing for a smaller package size. This should enable faster loading times if you use the self-hosted version of CommandBar within your app. It is especially noticeable if your app includes multiple dependencies that CommandBar also requires.

Note that this only applies to the self-hosted version of CommandBar, not the traditional CommandBar installation.

Learn more about self-hosting CommandBar

After, ahem, releasing CommandBar releases a few months ago, we're shipping some improvements based on tremendous feedback we've received. These changes address some common pain points when using the feature for version control.

The main theme of the changes is to make it easier to understand what changes are shipped when, to handle situations when multiple product owners are involved in the release process.

• A new UI allows you to view the release history for each environment (so you can see if someone made a release before you)
• Add notes and tags to environments. That way you'll know why the release was made, and you can note whether it involves bug fixes, improvements, new commands, new recommendation rules, etc.
• Compare changes across releases to understand the diff between the two.

And finally, we also heard that it can sometimes be useful to pin a version directly when init-ing. For example, if you want to make sure users in production see a certain version, you can guarantee that using the code below. Note that if you do this, you won't be able to make any changes to production (or wherever the version is pinned) without making a code change.

Here are some of the more subtle (but important!) details we shipped in the month of April.

• React 18 is fresh out of the oven, and CommandBar is proud to support it.
• Attaching default shortcuts to commands in the Editor now comes with a recording interface (instead of the old selector interface)
• We cater to a lot of end users at CommandBar, and sometimes those users access CommandBar on weaker internet connections. For these situations, we've improved how we handle backoff retry requests to preserve client-side resources.

We've added new SDK methods to make it possible to control the behavior of CommandBar categories via code. It's always been possible to add commands via code (though we still recommend the Editor for most situations). However, when creating programmatic commands it was still necessary to use the Editor to create categories to which those programmatic commands could be linked.

Now, you can simply specify a category string in CommandBar.addCommand, and command will create a category corresponding to that string -- making the programatic command "just work" without any corresponding config changes in the Editor. The programmatic category's settings can be adjusted using CommandBar.setCategoryConfig.

Code example

// Most common: define a new category inside of addCommand window.CommandBar.addCommand({ text: 'Go to Home', name: 'go_to_page_home', template: { type: 'link', value: '/home', operation: 'self' // how should the page open }, category: 'Navigation', });

// Less common: define a new category before using it window.CommandBar.setCategoryConfig( "Navigation", { search_tab_enabled: true } );

window.CommandBar.addCommand({ .... category: 'Navigation', ...

Here's a list of some of the smaller details we shipped this month, bottled for CommandBar connoisseurs.

• Enable search by customized shortcut. If an end user customizes a shortcut, we'll now let them query commands using that shortcut.
• Added autocomplete to the availability and recommendation condition editors. This makes it easier to reference context keys that are already defined (no more was it "context.userID or context.username?")
• If you've defined a router function for reloadless navigation, whenever you create a new navigation command CommandBar will default to using the router.
• When filtering by a major category, the results list will be fully expanded by default (an end user won't have to select "see more" to expand the category...since there's nothing below it.

Here's a list of some of the smaller details we shipped this month.

Companies utilizing our startup pricing program to get CommandBar credits (see details here to see if you're eligible) will now see those credits on the billing page. Added a way to prevent context loader functions from being called on page load or when CommandBar is closed. // Will prevent loader from being called on page load or bar close

window.CommandBar.addContext(key, []);

window.CommandBar.addContext(key, loader);

Fixed a bug preventing records from loading when categories have infinite scroll enabled When setting default keyboard shortcuts from the Editor, we now show a special warning when your shortcut uses a browser-reserved shortcut, which cannot be processed by CommandBar unless your app is shipped as a desktop application.

The Editor allows you and your team to make new commands and change commands quickly. But if you have a big team contributing to your CommandBar, you might want to control when CommandBar changes are made available to users.

Introducing Releases, release management for CommandBar. You can read about the details here but the gist is:

• If Releases is turned on, you can create a number of CommandBar environments that correspond to snapshots of the CommandBar config (the GIF shows Latest --> QA --> Prod).
• Changes made in one environment can be promoted to the next one.
• You can specify which environment to load in your CommandBar init method (e.g. to make Prod available to end users and QA available to your QA team)
• A CommandBar admin can also toggle the active environment from a new settings panel inside the CommandBar

Let us know if you'd like to try out releases so we can enable it for your organization. Then, you can turn on releases from the Editor Settings tab, under Releases!

Here's a list of some of the smaller details we shipped in January 2022.

We shipped some performance improvements that make CommandBar open much faster than before. Valtio-inside. We shifted our state management infrastructure to Valtio which has made CommandBar much easier to develop on. You'll see this show up as a faster flowing changelog :) Option filtering now supports "truthy" boolean operators (it used to coerce "true" to a string). Admins can now login and signup using Google auth, in addition to setting a custom password.

Availability conditions control when commands can be shown to a user. You can use them to disable commands for different classes of user (like disabling admin commands for regular users) or making certain commands available in specific parts of your app.

Commands that aren't available are not shown in the bar by default, in either the empty state or search state.

Sometimes, that can be confusing for users. For example, what if a colleague told them to use a command but their user group didn't have access to it? To them, it would seem as though the command didn't exist.

Disabled commands fix this problem by showing unavailable commands to the user (disabled, of course) along with a reason explaining why the command is disabled. You can add a different reason for every availability condition attached to the command.

How to turn on:

• Add an availability condition to a command
• Set a "Reason" for why the command is not available to the user

CommandBar lets product teams put relevant functionality in front of users, through availability and recommendation conditions. Today we're releasing Rules, which make it easier to define and reuse segment definitions across commands.

Rules are collections of more granular conditions -- using metadata or other properties of the user's session. You can define a rule once and then re-use it on any command. This is especially helpful when you need to define a complex set of conditions. Using a rule means you can also more easily share the definition with other folks on your team.

You can create rules in the new Rules section of the Commands tab, and you can apply them when defining availability and recommendation conditions for individual commands.

To make it easier to get started with rules, the Rules tab will scrape your commands for existing conditions to allow you to turn them into a rule.