Editor tools

How the tools open

These tools only exist inside the code editor; they are not pages of the main pager. Open a file or a project first, then use the wrench button at the top of the editor.

1. 1Tap the wrench button (More options) in the editor’s top bar. A sheet opens with a search field, Search action….
2. 2Pick a section chip: Edit, View, Go to, Git, AI or Tools, or type in the search field to filter every action at once.
3. 3In Tools the actions are grouped as Run, Project, Collaborate, Utilities and Help & settings. Debug, Test Explorer and Dependencies are under Run; Docker Tools, Monitoring and Backend Generators under Project; Live Collaboration under Collaborate.
4. 4Problems and Outline are under Go to. AI Generators and the AI code actions are under AI.
5. 5The command palette (Ctrl+Shift+P on a hardware keyboard) lists the very same actions: the menu and the palette share one registry.

Where each tool is

Sheet, docked panel, dialog or column

Shortcuts

Debug

Debug runs the open file with a debugger attached and shows what the program is doing in a panel docked under the editor. The debugger is real for JavaScript only (.js, .mjs, .cjs, .jsx, run on the built-in Node.js). For any other language Debug File just runs the file.

Breakpoints

• Tap a line number in the editor to add or remove a breakpoint, or press F9 on the cursor’s line (Toggle breakpoint). You can set them before you start the session.
• Breakpoints live in memory only: closing the app forgets them.
• The Breakpoints tab lists every breakpoint with an on/off box. Tap a row to jump to its line in the current file, use the pencil to edit it, ✕ to remove it, or Clear all. Empty list: “No breakpoints. Tap a line number in the editor to add one.”

Starting and stepping

Node starts paused on its first line (--inspect-brk), the panel attaches (“Debugger attached on port N” appears in the run output) and releases it, and the program runs until it hits a breakpoint or an uncaught exception, which also pauses it.

• With a session active the toolbar offers Continue (or Pause while it runs), Step Over, Step Into, Step Out, Restart and Stop. The step buttons are active only while the program is paused.
• Stop detaches the debugger. The process itself is stopped from the run panel.
• The flame toggle, Hot Reload: restart the session when a project file is saved, is off by default.

The four tabs

The tab names are always in English: the app doesn’t translate them.

Conditions and logpoints

The pencil of a breakpoint opens Edit breakpoint. Condition (“Pause only when this JavaScript expression is true”) makes it stop only then. Log message (“Log instead of pausing. Use {expression} to insert values”) turns it into a logpoint that prints the message and does not pause. With both, it prints only when the condition is true. These two fields are set here, not from the editor margin.

Testing

The Test Explorer finds your project’s tests, runs them with the framework’s own command and lists the results. It does not ship a test runner: it runs the command through the device’s shell (sh -c) in the project folder, so the framework’s tools must exist on the device.

Frameworks and detection

Twelve frameworks are supported: Jest, Mocha, Vitest, pytest, unittest, JUnit, Go Test, Cargo Test, PHPUnit, RSpec, Dart Test and Swift XCTest. PocketCode picks one per project: the first it finds by its config file (for example jest.config.js, pytest.ini, build.gradle, go.mod, Cargo.toml, pubspec.yaml); if none matches it reads package.json for Jest, Vitest or Mocha. unittest has no config file, so it is never picked on its own. The subtitle then reads “<framework> · N tests in M files”.

The four tabs

Running

• The footer has Run all, Failed only and, while a run is going, Stop.
• The header has icons for Refresh, Toggle watch mode and Run with coverage.
• The test tree comes from reading your files with name patterns (*.test.*, test_*.py, *_test.go, *Test.kt…), up to 200 files, skipping node_modules, .git, build, dist, target, .gradle, __pycache__ and venv.
• Watch mode exists for Jest, Mocha and Vitest only, and it just streams the command’s output into Output.

Docker Tools

Docker Tools is a front end for the docker command-line tool that is already on your device. PocketCode does not include Docker or a Docker daemon, and the panel has no field for a remote host. So on a typical phone the tabs that need Docker show Docker isn’t reachable, while the Dockerfile and Compose editors keep working.

When Docker isn’t there

On opening, the panel runs docker --version. If that fails, Containers, Images, Build and Registry show Docker isn’t reachable: “PocketCode runs the docker command on this device and couldn’t find it. You can still edit the Dockerfile and the Compose file.” It adds the real cause of the failure and two buttons, Try again and Edit Dockerfile. The subtitle reads Docker not available.

Dockerfile and .dockerignore

This tab works without Docker. Start from one of 14 templates — Node.js App, Python App, Java App, Go App, Rust App, Static Site, React App, Next.js, FastAPI, Spring Boot, Django, Ruby on Rails, Laravel, Custom Multi-stage — edit the text and Save it as Dockerfile in the project. For .dockerignore you can Generate a file and save it.

Compose

Nine templates: Full-stack Node.js, Full-stack Python, Full-stack Java, LAMP Stack, MEAN Stack, Monitoring Stack, ELK Stack, WordPress and Dev Tools. Edit and Save the file; it is always saved as docker-compose.yml, although the panel reads docker-compose.yml, docker-compose.yaml, compose.yml or compose.yaml. With Docker present, Compose up, Compose down, Compose build and Compose logs run docker compose up -d, down, build and logs --tail=100; they stay disabled until the project has a Compose file.

With Docker available

Limits of the commands

Each command may run for 300 seconds at most. Names and tags are checked before they reach Docker: letters, digits and _ : . / @ -, up to 255 characters, and not starting with -.

Monitoring

Monitoring measures the app you are running in and the device it runs on, not a server. It samples every 2 seconds while the panel is open and stops when you close it. To see your own server there is a separate Server tab.

The five tabs

Alert rules

The rule form has Metric, Condition (Greater than or Less than), Threshold (checked against the metric’s range), Sustained for (seconds) and Severity (Critical, Warning, Info). Alert events are evaluated and shown only while the panel is open; the last 100 are kept, at most one per minute per rule.

Server: your own Prometheus

Server works with Prometheus, VictoriaMetrics, Thanos, Mimir, Cortex or a Grafana proxy. Enter the Address, choose Authentication (None, User and password or Bearer token), pick the refresh (5 to 300 seconds, 15 by default) and add up to 12 queries; each is a PromQL instant query that must return a single value. Test connection checks the setup. Until you configure it, the tab reads “No server configured. Nothing leaves this device until you set one up.”

Libraries

Libraries (the menu calls it Dependencies) is not a package manager. It lists the Kotlin/JVM libraries a project declares in .pocketcode/dependencies.json and lets you pick from a closed catalog of four libraries that ship inside the PocketCode app. Only the full Kotlin runner uses them.

Catalog

The Catalog tab lists the four libraries PocketCode includes: kotlinx.coroutines 1.10.2, kotlinx.serialization · JSON 1.7.3, kotlinx.serialization · core 1.7.3 and Okio 3.9.1. The + icon of a row (Add plus the library name) adds it to the project.

Declared

The Declared tab lists what the project’s JSON declares, with the filters All, Outdated and Not included. Each row shows group:artifact and whether PocketCode includes it (“Included with PocketCode.”, or “a → b” when the project asks for another version), with an update icon and a remove icon. Update N at the bottom updates every outdated library, which means setting it to the version PocketCode includes. The refresh icon in the header (Resolve now) prepares the libraries again, with the states “Preparing the libraries…” and “Ready: this project’s libraries are prepared.” Without declarations it reads No dependencies.

A library that isn’t included

If the JSON names something outside the catalog, the row says it doesn’t come with PocketCode, “so this project runs in simple mode. Remove it, or use one of the libraries above.”

Backend Generators

Backend Generators write server code from templates stored in the app. It is not AI: the same settings always give the same files (the Generate buttons simply wait a moment first). You read the result in the sheet and, with a project open, save it under backend/.

The tabs

Save to project

Save to project writes the generated files under backend/ in the project; migrations become backend/up.sql and backend/down.sql, and the spec backend/openapi.yaml or backend/openapi.json. Paths can’t leave the project folder. If some files exist it asks Overwrite files? (“N file(s) already exist in the project and will be overwritten.”). On success it says “Saved N file(s) to backend/ in the project”, and if writing fails “Couldn’t save the generated files”. It needs a project open.

AI Generators

AI Generators has five tabs, but only three use AI. API and Schema are offline templates that run on the device; Translate, Security and Performance send the code you paste to your connected AI provider.

The five tabs

What the AI tabs need

A connected AI provider and internet access. The first time, a notice asks Send to <provider>?; Send shares the code you pasted, Cancel shares nothing. API and Schema need neither a provider nor a network. Before generating, the result area reads “The result will appear here once generated.”

AI code actions

The AI section of the menu has actions that work on your code: explain, tests, docs, code from comments, refactor and five quick actions. They send the code to your connected AI provider, after a notice you accept, and show the answer.

The actions

Apply and Insert in the docked panel

The docked panel is at most 300 dp high and has a ✕ to close. Insert puts the answer at the cursor. Apply replaces only the piece of code that was sent to the AI (the function for Generate Docs; the selection for Refactor, or the whole file when nothing was selected) with the answer, with no preview and in one undo step. If you changed that code while the AI was answering and it can’t be found any more, nothing is touched and the panel says “The code changed while the AI was answering, so the result was not applied. Copy it instead.” Copy, beside the generated code, copies it to the clipboard (“Copied to clipboard”); the bottom sheet has its own Copy for the whole answer.

Live Collaboration

Live Collaboration lets two or more devices edit one file together on the same Wi-Fi network. It is free, needs no account and has no server: the host’s phone listens on your local network, guests find it, type a six-digit code and the host lets them in. Nothing goes over the internet.

Host a session

1. 1Under Host on this device type a session name and tap Start hosting. The session shares the text of the file you have open.
2. 2Give the six-digit Pairing code to whoever is joining (“Give this code to whoever is joining”).
3. 3When someone types the right code, your device asks Someone wants to join: “<name> typed the right code. Letting them in shares the file with their device.” Choose Let them in or Turn away. You have up to 90 seconds.
4. 4End it with End Session in the header.

Join a session

1. 1Open the panel on the same Wi-Fi. Peers on your network scans the LAN (Scanning the LAN…) and says No peers found if nobody is hosting.
2. 2Type the host’s six digits in Code from the host (“Nobody can join without it. The session never leaves your network.”).
3. 3Tap the host and wait for it to let you in (up to 120 seconds). The contents of the file you had open are replaced by the host’s text.
4. 4Leave with Leave in the header.

Inside a session

What is shared

• The text of the host’s active file at the moment the session starts. A session shares one buffer: not the project tree, not other files.
• After that, everyone’s edits merge (CRDT) and the remote cursors appear in the editor with a name and a colour.
• The host relays everything: guests talk to the host, not to each other.
• Every guest the host lets in can edit the shared text.
• If a guest’s connection drops, the app retries up to six times (1 s growing to 15 s) and reconciles what was typed in the meantime.

Network and permission

From Android 13, hosting and joining need Android’s nearby-devices permission (on the newest Android versions it is a local-network permission). When you start hosting, scan or join and it is missing, Android’s own permission dialog opens: allow it and tap again. If you refuse, hosting and joining stay refused (the next attempt shows the explanation again) until you allow it from Android’s settings for the app. The permission explanation and the connection errors are shown in the language of the app.

Problems

Problems is one list of everything the editor has found wrong in every open tab, grouped by file. It is a full-screen dialog, not a sheet.

Filters

Filter by origin — Compiler/LSP, Markers and Style, each with its count — and by severity — Errors, Warnings, Info and Hints. Compiler/LSP and Markers are on by default. Style (the linter rules) is computed only when you switch it on, with “Analyzing style…”, and nothing is computed while the dialog is closed.

Rows

Problems are deduplicated and ordered by severity, then line. Tap a row to go to “Line N, Col M”. The group of the active file has Quick fixes, which opens the quick-fixes panel. F8 and Shift+F8 jump to the next or previous error, warning or TODO marker without opening the dialog. With nothing to show it reads No problems found.

Outline

Outline is a column on the right of the editor that lists the file’s classes, interfaces, functions, import blocks and // region sections and jumps to them. A simple parser builds it; it does not use the language server.

What it recognises

• Lines that start with class, interface, object, enum class, fun or suspend fun and open a { — Kotlin-style declarations.
• Blocks of three or more consecutive lines that start with import .
• Regions written as // region Name and closed with // endregion.
• It refreshes 0.8 seconds after you stop typing.

Using it

Type in Filter symbols… (it matches part of the text, it is not fuzzy) and tap an entry to go to its line. No symbols appears when the filter matches nothing.