DEV Community: Muhammad Hammad Khan

Set Up Zoo Code in Android Studio (macOS and Windows)

Muhammad Hammad Khan — Tue, 03 Nov 2026 09:05:10 +0000

By Muhammad Hammad Khan

A complete installation and first-run guide for macOS and Windows.

What this guide covers

Preparing Android Studio, downloading and installing the Zoo Code JetBrains plugin, opening its tool window, connecting an AI/API provider, choosing a model, running a first task, and configuring Auto-Approve permissions safely.

Important compatibility note — read before installing

As of 3 November 2026, the Zoo Code JetBrains project lists Android Studio 2026.1.4 or newer as required, and says 2026.1.4 is currently available through the preview channel. Zoo Code also requires a JCEF-enabled IDE runtime to display its interface. Do not assume that an older stable Android Studio build will work just because the plugin appears installable.

1. Before you begin

Zoo Code is an AI coding agent integrated into the IntelliJ platform. It is not itself an AI model: you connect it to a model provider (for example OpenAI, Anthropic, OpenRouter, Google Gemini, or a compatible/local provider) and normally supply an API key or other provider credentials.

Android Studio: install Android Studio 2026.1.4 or newer, with JCEF support enabled.
Internet: needed to download the plugin and, on first launch, its platform-specific Node.js runtime unless a suitable fallback is available.
Provider account: create an account with your chosen AI provider and generate an API key if that provider uses API-key authentication.
Project: have an Android project ready, or create/open one after installing Zoo Code.

You do not normally need to install Node.js manually. The JetBrains plugin automatically downloads a pinned, platform-specific Node.js runtime on first launch. If that download fails, it can fall back to bundled Node.js or Node.js 20.6.0+ on the IDE process PATH.

2. Install Android Studio

macOS

Open the official Android Studio download page: developer.android.com/studio.
Download the macOS build that matches your Mac (Apple silicon or Intel, where offered).
Open the downloaded DMG and drag Android Studio into Applications, following the installer instructions.
Launch Android Studio. If macOS asks whether to open an app downloaded from the internet, verify that you downloaded it from the official Android developer site before proceeding.
Complete the first-run setup wizard and allow it to install the Android SDK and recommended components.
For Zoo Code, make sure you are using Android Studio 2026.1.4 or newer. If that version is still marked Preview, select the appropriate preview channel/build from the official Android Studio download page.

Windows

Open developer.android.com/studio.
Download the Windows 64-bit installer.
Run the installer and follow the setup wizard. Keep the Android Studio and Android Virtual Device components selected if you need them.
Launch Android Studio and complete the first-run setup wizard, including Android SDK installation.
Use Android Studio 2026.1.4 or newer for Zoo Code. If required, install the preview build from the official download page.

Version check: In Android Studio, open Help → About on Windows/Linux or Android Studio → About Android Studio on macOS. Confirm the installed version before proceeding.

3. Download the Zoo Code plugin

The JetBrains integration is distributed as a ZIP plugin from the official Zoo-Code-Org GitHub Releases page. This is different from installing the VS Code extension from the VS Code Marketplace.

Open the official repository: github.com/Zoo-Code-Org/Zoo-Code-Jetbrains.
Open its Releases page: GitHub Releases.
Download the latest release asset that is the installable JetBrains plugin ZIP (the filename is typically similar to ZooCode-…zip). Do not unzip it.
Keep the ZIP somewhere easy to find, such as Downloads.

Use the release ZIP for normal installation. The repository also documents a build-from-source workflow, but that is intended for developers contributing to or building the plugin and is not required for ordinary users.

4. Install Zoo Code in Android Studio

The following plugin installation steps are the same on macOS and Windows; only the name of the IDE settings menu differs.

macOS: Android Studio → Settings/Preferences → Plugins. Windows: File → Settings → Plugins.
In the Plugins screen, select the gear icon near the plugin search/results area.
Choose Install Plugin from Disk….
Browse to the Zoo Code plugin ZIP downloaded in the previous section and select it. Leave the ZIP compressed.
Confirm installation if Android Studio prompts you.
Restart Android Studio when prompted. A restart is important because the plugin loads into the IDE runtime.
After restart, locate the Zoo Code tool window, usually on the right-hand tool-window stripe. Click it to open the chat panel.

If the tool window does not appear, first confirm that the plugin is enabled under Settings → Plugins → Installed, then restart the IDE. See the troubleshooting section for JCEF and runtime checks.

5. First launch and connect an API provider

Zoo Code needs an LLM inference provider before it can generate or edit code. Provider availability and exact fields depend on the provider and the Zoo Code version.

Create or obtain provider credentials

Choose a provider. Examples include OpenAI, Anthropic, OpenRouter, Google Gemini, DeepSeek, xAI, or a compatible gateway. Local-model options include Ollama and LM Studio.
Create/sign in to your account on that provider's official website.
If required, open the provider's developer/API dashboard, create an API key, and copy it. Some providers require billing activation or account verification before API calls work.
Treat the API key like a password. Do not paste it into source code, screenshots, public documentation, Git commits, or a shared settings export.

Configure the provider in Zoo Code

Open the Zoo Code tool window in Android Studio.
If a first-run welcome/setup screen appears, select the provider you intend to use and follow its prompts.
If you are already inside the Zoo Code chat, click the gear icon to open Zoo Code settings.
Open the Providers section.
Use the + button beside the profile selector to create a new API configuration profile. Give it a descriptive name, such as OpenAI – Android Work or OpenRouter – Personal.
In that profile, choose the API provider from the provider dropdown.
Paste the API key into the provider's API-key field (or complete the provider's authentication flow if it uses another method).
Choose a model supported by that provider. Check the provider's current model catalogue and ensure the selected model supports tool/function calling; coding-agent tasks rely on tool use.
Review any provider-specific fields, such as base URL, deployment/region, organization, or model options. Only fill fields that the provider requires.
Save/close settings if the interface offers a save action. Select the new profile in the profile selector so it is active.

You can switch profiles later from the Providers settings page or from the API Configuration dropdown in the chat interface. Profiles can store different providers, keys, models, and model settings. The exact options differ by provider.

Provider choice: OpenRouter can be convenient if you want to access models from multiple providers through one account/key. Direct provider integration is useful when you specifically want that vendor's own API. For local inference, configure Ollama or LM Studio and ensure the local model is running and reachable.

6. Start Zoo Code and run a first task

Open an Android project in Android Studio and wait for Gradle sync/indexing to finish.
Open the Zoo Code tool window.
Check the active API configuration/profile and model in the chat interface.
Choose a mode. Ask is suitable for questions and explanations; Architect is useful for planning; Code is for implementation; Debug is for diagnosing problems.
Start with a low-risk request, for example: “Inspect this project and explain its main modules and entry points. Do not modify any files yet.”
Review the response. Next, try a small implementation request on a branch or copy of the project.
When Zoo Code proposes an action, inspect the proposed operation and approve or reject it as appropriate. Depending on the action, it may read files, edit files, or request a terminal command.

A useful first coding prompt is specific about the outcome, files or feature involved, constraints, and whether changes are allowed. Ask Zoo Code to explain its plan before making broad changes.

7. Configure Auto-Approve permissions

Auto-Approve controls which operations Zoo Code may perform without asking you to approve each one. This can make repetitive work faster, but it also removes an important safety checkpoint. Start with approvals disabled or narrowly scoped; do not select “All” simply to make the agent run unattended.

Quick controls in the chat panel

In the Zoo Code chat panel, find the Auto-Approve dropdown beside the chat input.
Open it. The dropdown contains permission tiles and an Enabled master switch.
Keep Enabled off while reviewing the available permissions. Selecting permission tiles does not by itself activate auto-approval if the master switch is off.
Select only the specific permissions you understand and want to allow. Use None to clear the selected permissions. Use All only if you deliberately want every listed category enabled.
Turn Enabled on only when you are ready for the selected operations to be auto-approved. Turn it off to pause all auto-approval; your individual selections remain saved.

Detailed controls in Zoo Code settings

Open the Auto-Approve dropdown in the chat panel.
Click its gear/settings icon in the top-right area.
Open Auto-Approve Settings (or the equivalent Auto-Approve section in the settings panel).
Review each permission category below and enable only what is needed for your workflow.
Return to the chat and confirm the global Enabled switch is in the intended state.

What the permission categories mean

Permission	What it allows	Risk / guidance
Read files and directories	Read project files and folder contents without asking.	Medium. A sensible starting point if restricted to the workspace.
Edit files	Create or modify files without asking.	High. Prefer manual approval until you trust the workflow.
Execute approved commands	Run terminal commands that match your configured allowlist.	High. Use narrow command prefixes; never allow all commands casually.
Use the browser	Use browser-related tools without asking.	Medium. Consider what sites and data the agent can access.
Use MCP servers	Use configured Model Context Protocol tools.	Medium–High. Requires the global setting and each tool's own Always allow checkbox.
Switch modes	Switch between modes without asking.	Low. Changes the agent's working mode.
Create & complete subtasks	Manage subtasks without asking.	Low. Workflow convenience.
Answer follow-up questions	Choose the default suggested answer after a timeout.	Low. Review the timeout and whether unattended continuation is appropriate.

Important details for command execution and file boundaries

Command allowlist: “Always approve allowed execute operations” is not a blanket permission to run every command. Add only specific, trusted command prefixes to Allowed Commands. Keep a Denied Commands list for dangerous operations; deny rules can take precedence over matching allow rules.
Never use * as an allow-all command prefix on a normal development machine. Commands such as destructive file deletion, disk formatting, privilege escalation, shutdown/reboot, publishing, and pushing code can have serious consequences.
Outside-workspace access: separate options control whether Zoo Code can read or write files outside the current project. Keep these disabled unless a task genuinely requires it.
Protected files: an additional option can allow changes to protected Zoo/Roo configuration files. Leave it off unless you understand why the agent needs to edit them.
MCP: enabling the global “Always approve MCP tools” setting is not enough by itself. You must also mark each individual MCP tool as “Always allow”.
Global Enabled switch: auto-approval only operates when Enabled is on and at least one permission is selected. Enabled off pauses all selected auto-approvals.

Recommended beginner setup: allow read-only access within the project if you are comfortable with it; keep automatic file writes, terminal execution, browser use, and MCP permissions off until you have reviewed how Zoo Code behaves. Approve edits and commands individually at first.

8. macOS and Windows keyboard shortcuts

The Zoo Code documentation lists these default shortcuts for toggling Auto-Approve:

macOS: Cmd + Option (Alt) + A
Windows: Ctrl + Alt + A

If a shortcut does not work in the JetBrains integration, use the Auto-Approve dropdown in the Zoo Code chat panel. Shortcut registration can vary by IDE keymap or plugin version. The VS Code documentation also describes a Command Palette toggle, but do not assume every VS Code command name or shortcut is exposed identically in Android Studio.

9. Troubleshooting

Zoo Code tool window is blank or does not render

Confirm that your Android Studio version is 2026.1.4 or newer and that the IDE runtime supports JCEF.
For IntelliJ Platform 2026.2 / build 262 and later, JCEF is distributed as a separate bundled plugin. Open Settings → Plugins → Installed, find the bundled JCEF plugin, enable it if disabled, and restart Android Studio.
On older supported IDE builds, JCEF is supplied by the IDE runtime; check the Zoo Code JetBrains repository's Known Issues page if rendering still fails.

Plugin fails to start or extension host fails

Restart Android Studio after installing the plugin.
Check the IDE progress/status area on first launch for a “Downloading Node.js runtime” task.
Allow Android Studio to reach nodejs.org. If using a local Node.js fallback, confirm Node.js 20.6.0 or newer is available on the IDE process PATH.
Inspect the Android Studio IDE log for Zoo Code or Extension Host errors.

Provider or model errors

Check that the API key is copied correctly and belongs to the selected provider.
Confirm that the provider account has API access, available credits/billing, and no account-level restrictions.
Confirm that the model identifier is valid for that provider and supports tool/function calling.
For an OpenAI-compatible endpoint, verify the base URL, authentication format, and model ID with that gateway's documentation.
Try a simpler supported model/provider profile to isolate whether the issue is provider-specific.

Plugin installation fails

Make sure you downloaded the JetBrains plugin ZIP from the Zoo Code JetBrains GitHub Releases page—not a VS Code .vsix file.
Do not extract the ZIP before selecting it in Install Plugin from Disk.
Check Android Studio compatibility and ensure the plugin is enabled after restart.

10. Final checklist

Android Studio 2026.1.4 or newer installed.
JCEF is available and enabled.
Latest Zoo Code JetBrains release ZIP downloaded from the official repository.
Plugin installed through Settings/Preferences → Plugins → Install Plugin from Disk.
Android Studio restarted and Zoo Code tool window opened.
Provider profile created with a valid API key or authentication.
A tool-capable model selected and active.
A harmless first task completed successfully.
Auto-Approve reviewed carefully; only necessary permissions enabled.
Automatic terminal execution and outside-workspace access left off unless specifically required.

Official references

A note on sources: Zoo Code’s general documentation is primarily written for its VS Code extension. This guide applies the documented provider-profile and Auto-Approve concepts to the JetBrains integration, while the plugin download/install path and Android Studio compatibility requirements come from the official JetBrains repository. Re-check the repository and documentation after major releases.

Muhammad Hammad Khan

Connecting Figma MCP to Zoo Code (macOS and Windows, using Codex CLI)

Muhammad Hammad Khan — Tue, 03 Nov 2026 08:50:30 +0000

By Muhammad Hammad Khan

A practical setup and troubleshooting guide for connecting Figma's hosted remote MCP server to Zoo Code inside Android Studio, using Codex CLI, without requiring a Claude subscription. The macOS process reflects the setup actually completed; Windows credential handling is marked where it was not tested.

Critical configuration detail: "type": "streamable-http" (not "type": "http") resolved Zoo Code's "Invalid MCP settings format" error in the tested setup.

Version context: Zoo Code 3.90.0, Android Studio, Figma remote MCP, Codex CLI

1. Overview and safety

The remote Figma MCP endpoint is https://mcp.figma.com/mcp. It works with browser-based Figma; the Figma desktop app is not required for the remote server.

Codex CLI was used to authorize Figma. Claude Code was briefly explored but not used for the final connection, because the goal was to avoid buying a Claude subscription just to authorize Figma.

This workflow uses a workaround/helper to transfer an existing Figma MCP credential into Zoo Code. It is not an officially documented, first-party Figma-to-Zoo-Code integration. Figma notes that direct remote-server support is limited to listed clients; support and authentication behavior can change.

Security rules

Never publish a bearer token, Keychain export, credential file, or screenshot that reveals a token.
Back up configuration before editing; do not commit mcp_settings.json or local credential files to Git.
Keep the normal Codex configuration intact. Do not expose credentials in chat or shell logs.
Only authorize an account permitted to access the target Figma file.

MCP vs Code Connect

MCP lets the coding agent call Figma tools to read design context. Code Connect is an optional mapping from Figma components to real components in a codebase. Code Connect was not required to establish the MCP connection.

2. macOS: completed workflow

Step 1: Verify Node.js and npm

node --version
npm --version

Step 2: Install and verify Codex CLI

npm install -g @openai/codex
codex --version

The tested machine reported Codex CLI 0.163.0. Your version may differ.

Step 3: Sign in to Codex CLI

codex login

Complete the browser-based sign-in flow. Codex must be authenticated before the helper can launch the Figma MCP login flow.

Step 4: Start Figma authorization through the helper

npx figma-mcp-auth mint

The helper launched a Codex MCP login flow using an isolated CODEX_HOME, opened a browser, and asked for Figma authorization. Sign in to the intended Figma account and click Allow. The isolated home was intended to avoid changing the normal Codex setup.

Do not use the Claude route. The Claude-specific path would require Claude Code authentication; Codex CLI was chosen instead to avoid a Claude subscription.

Step 5: Verify Codex has the Figma MCP server

codex mcp list

Confirm the figma entry points to https://mcp.figma.com/mcp and shows OAuth enabled. The list does not need to display the token.

Step 6: Diagnose the helper's Keychain lookup

The first injection attempt failed because the helper could not find a Figma token. On the tested Mac, Keychain metadata showed this arrangement:

service: Codex MCP Credentials
account: figma|<client-id>

The helper originally expected the opposite arrangement (service beginning with figma| and account Codex MCP Credentials). The local helper's lib/keyring.js was adjusted to search the actual Mac Keychain arrangement. A safe check then confirmed a matching credential and valid access token without printing the secret.

Step 7: Check the helper's URL constants

The inspected published package had malformed URL constants in its local source. They were corrected only after inspecting that package build. If your installed version already has correct constants, do not overwrite them.

const MCP_URL = "https://mcp.figma.com/mcp";
const AUTHORIZE_URL = "https://www.figma.com/oauth/mcp";
const TOKEN_URL = "https://api.figma.com/v1/oauth/token";
const REGISTER_URL = "https://api.figma.com/v1/oauth/mcp/register";
const PROTECTED_RESOURCE_URL = "https://mcp.figma.com/.well-known/oauth-protected-resource";
const SCOPE = "mcp:connect";
const KEYRING_ACCOUNT = "Codex MCP Credentials";
const KEYRING_SERVICE_PREFIX = "figma|";

OAuth endpoints and helper internals can change. Inspect the version you are actually using; if the constants differ, consult the package maintainer and current Figma docs rather than guessing.

Step 8: Save the matching credential to the helper's local store

A local transfer script read the matching Keychain credential and saved it to the helper's local token store. It validated that the credential matched the Figma MCP URL and was unexpired, and reported the expiry without printing the token. This transfer script was environment-specific; do not recreate it by guesswork or expose the secret.

Step 9: Open Zoo Code's global MCP settings

In Android Studio, open Zoo Code → MCP Servers → Edit Global MCP. The tested macOS path was:

~/.zoo-code/globalStorage/wecode-ai.zoo-code/settings/mcp_settings.json

The file initially contained an empty mcpServers object. Back it up before editing.

{
  "mcpServers": {}
}

Step 10: Inject the credential

After the local token store was populated, the helper's dry run showed that it would update the figma entry. Review dry-run output first, then run:

npx figma-mcp-auth inject --client codex --target zcode

The helper reported that the Zoo Code settings file had been updated. Command behavior can vary by package version; check its README/help before running it in another environment. Do not inject before token lookup succeeds.

Step 11: Correct the transport type (critical fix)

The first config used "type": "http" and Zoo Code returned Invalid MCP settings format: mcpServers.figma: Invalid input. Changing the value to "streamable-http" resolved the validation error.

{
  "mcpServers": {
    "figma": {
      "type": "streamable-http",
      "url": "https://mcp.figma.com/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_EXISTING_TOKEN"
      }
    }
  }
}

Keep the real token only in your local file; the placeholder above is for documentation. Preserve all quotes, commas, and braces. The endpoint must be the plain URL shown, not a Markdown-formatted link.

Step 12: Restart and test

Restart Zoo Code or start a fresh agent session.
Ask: "List the available tools from the Figma MCP server."
Paste the complete Figma file URL and ask the agent to inspect a specific frame/node.
If it asks for fileKey, provide the file URL. Server configuration alone does not identify the file you want to inspect.

3. Windows: equivalent steps and important limitation

The successful credential transfer described above was performed on macOS. The helper version was adjusted for macOS Keychain; Windows uses a different credential store. Do not treat the Windows credential-transfer portion as verified end-to-end until tested on a Windows machine.

Step 1: Install prerequisites

Install Node.js from nodejs.org. Open PowerShell and verify:

node --version
npm --version

Step 2: Install and authenticate Codex CLI

npm install -g @openai/codex
codex --version
codex login

Complete the browser-based Codex login. Then run the helper authorization command and approve Figma in the browser:

npx figma-mcp-auth mint

Step 3: Confirm Codex Figma entry

codex mcp list

Confirm the Figma entry and endpoint https://mcp.figma.com/mcp.

Step 4: Check Windows credential-store support before injection

The Mac-specific Keychain lookup cannot be used on Windows. Inspect the helper source and documentation to confirm it supports Windows Credential Manager or another secure Windows credential source. If it does not, stop and use a reviewed Windows-compatible method or ask the maintainer to add support. Do not print tokens or paste secrets into scripts, chats, or tickets.

Step 5: Locate Zoo Code global settings

In Android Studio, open Zoo Code → MCP Servers → Edit Global MCP. Use the actual path opened by the extension. If needed, search the user profile for mcp_settings.json under Zoo Code's globalStorage directory. Back up the file.

Step 6: Configure the server

{
  "mcpServers": {
    "figma": {
      "type": "streamable-http",
      "url": "https://mcp.figma.com/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_EXISTING_TOKEN"
      }
    }
  }
}

Use a real token only after secure, supported transfer. Do not use "type": "http" in the tested Zoo Code version.

Step 7: Restart and verify

Restart Zoo Code or create a new agent session.
Ask it to list Figma MCP tools.
Supply the complete Figma file URL and target frame/node.
If validation fails, check transport type, JSON syntax, endpoint, and header structure before debugging authentication.

4. Troubleshooting

Symptom	Meaning / fix
SSE error: status 405	The attempted SSE/endpoint combination was not accepted. Use the transport supported by this Zoo Code version.
HTTP 403 / invalid OAuth response	Direct OAuth was rejected for the attempted client. The workflow used Codex CLI authorization and a secure credential transfer instead.
Codex CLI not found	Install Codex CLI and verify `codex --version` works in the terminal you are using.
No Figma MCP token available	The helper could not find a credential in its expected store. Check its keyring assumptions and the platform credential store.
Invalid MCP settings format	In the tested Zoo Code build, changing `"type": "http"` to `"type": "streamable-http"` fixed validation.
Agent asks for fileKey	Provide the complete Figma file URL or a link copied from the target frame/selection.

5. End-to-end verification checklist

Codex CLI is installed and authenticated.
Codex lists the Figma MCP server and correct remote endpoint.
The helper can securely locate an unexpired credential without printing it.
Zoo Code's global config contains the figma server entry.
The transport is exactly streamable-http.
The endpoint is exactly https://mcp.figma.com/mcp.
Authorization is a Bearer header and the token remains private.
Zoo Code has been restarted or a fresh agent session opened.
The agent lists Figma tools and can read the target file when given its URL.

A config entry by itself is not proof of success. Confirm the agent can list tools and read the intended design.

6. Prompts to test the connection

Check tool availability

List the tools available from the connected Figma MCP server. Report any connection or authentication error exactly.

Inspect a design

Inspect this Figma design: PASTE_THE_COMPLETE_FIGMA_FILE_URL. Use the connected Figma MCP tools. Identify the file and target node from the URL. Read the selected frame's design context.

7. Code Connect (optional)

Code Connect maps a Figma component to the corresponding real component in the codebase. For example, it can map a Figma button to a reusable Jetpack Compose button so generated code can reuse the existing implementation. It is not needed just to read designs with MCP. Choose "Not now" unless your project has reusable components ready to map.

8. References

Figma: remote server installation
Figma: guide to the MCP server
Zoo Code: MCP configuration
Figma: troubleshooting tools that do not load

The macOS keyring fix and helper-source adjustments were specific to the package version and local environment. The Windows credential transfer has not been verified end-to-end.

Muhammad Hammad Khan