LocalMan for Visual Studio Code

The REST client you already know—without accounts, cloud workspaces, or another desktop app.
Build, run, organize, and inspect HTTP requests locally, directly inside VS Code and Kiro.

[!IMPORTANT] LocalMan requires no LocalMan account, subscription, login, or remote workspace. Collections, Environments, settings, and History stay in local files. HTTP requests are sent only to the endpoints you explicitly configure and execute.

Contents

• How LocalMan works
• Get started
• Create and send a request
• Request body formats
• Read a response
• Tabs, saved requests, and History
• Collections, Environments, scripts, and cURL
• Storage and privacy
• Commands
• Troubleshooting

How LocalMan works

LocalMan has two parts that work together:

1. The interface inside VS Code lets you edit requests, switch tabs, manage Collections and Environments, and inspect results.
2. The Extension Host performs network requests, accesses local storage, protects secrets, writes History, and opens downloaded files.

When you press Send, LocalMan follows this sequence:

1. It takes the request from the active tab.
2. It runs the pre-request script, if one is configured.
3. It resolves {{variables}} in the URL, parameters, headers, body, and authentication.
4. It applies the selected authentication method and sends the HTTP request.
5. It preserves the server response even when the status is 4xx or 5xx.
6. It runs the post-response script and saves Environment changes made by the scripts.
7. It displays the response in the same tab and adds the execution to local History.

Each request tab has independent request, response, error, cURL, and script-log state. Closing a tab while its request is running cancels that network operation.

Why LocalMan?

LocalMan brings the familiar REST-client workflow into the editor where you already work. There is no separate application to keep open, no mandatory synchronization service, and no account wall between you and a simple API request.

• No account required — install it and start sending requests.
• Local-first storage — use .local-man in the workspace or VS Code global storage.
• Integrated workflow — Sidebar, full editor, native trees, and Command Palette actions.
• Lightweight distribution — a compact extension instead of another desktop runtime.
• Private by design — no advertising, analytics, behavioral telemetry, or LocalMan cloud.
• Portable data — Collections, Environments, History, and settings use readable JSON files.
• Seven UI languages — English, Spanish, Simplified Chinese, Japanese, French, Portuguese, and German.

What you can do

Build and run HTTP requests

• Methods: GET, POST, PUT, PATCH, DELETE, HEAD, and OPTIONS.
• Query parameters and headers with enable/disable controls.
• Bodies: JSON, text, XML, form-data, URL-encoded, and binary Base64 data.
• Built-in JSON beautifier and validation in the request Body editor.
• Authentication: Bearer token, Basic Auth, API key, and an existing OAuth 2.0 access token.
• Configurable timeout, redirects, response duration, and response size, with a 25 MB transfer limit.
• HTTP error responses remain inspectable instead of being replaced by generic failures.

Set localman.timeoutMs in VS Code Settings to choose a request timeout from 100 to 300000 milliseconds. The default is 30000 milliseconds.

Work with tabs

Open multiple request tabs and switch between them without losing the response, error, script logs, or generated cURL from another tab. Each tab owns its own request and response state.

Organize Collections

• Create, rename, expand, and delete Collections.
• Save requests into a Collection and reopen them later.
• Manage Collections from the React interface or the native VS Code tree.
• Import Postman Collections and OpenAPI JSON/YAML definitions.

Use Environments and variables

Reference variables anywhere with {{variable}}:

{{baseUrl}}/posts/{{postId}}

Variables work in URLs, query parameters, headers, bodies, and authentication. Environments can be created and edited from the main interface or the native Sidebar tree. Values marked as secret are persisted through VS Code Secret Storage rather than plain JSON.

Import and export cURL

Paste a cURL command to create a request, or generate cURL from the active request for terminals, documentation, bug reports, and team handoff.

Inspect every response

• Pretty JSON—including JSON returned as plain text—and readable text, HTML, or XML.
• Status, status text, duration, size, and response headers.
• Inline image previews.
• File cards for PDF, XLS, XLSX, images, and generic binary responses.
• Save files or open supported binaries with the operating system's default application.

Automate with scripts

Run pre-request and post-response JavaScript in a restricted sandbox with a familiar minimal API:

pm.environment.get("key");
pm.environment.set("key", "value");
pm.request;
pm.response;
console.log("visible in LocalMan logs");

Scripts can update Environment values and request headers, produce visible logs, and inspect responses. Run scripts only from sources you trust. LocalMan is disabled in VS Code Restricted Mode because workspace files can contain request scripts and network targets.

Keep useful History

The latest 100 executions are stored locally and synchronized across:

1. The native VS Code History tree.
2. The LocalMan Sidebar interface.
3. The LocalMan full editor.

History lists stay small by loading complete request snapshots only when Re-run is selected. Authentication credentials and headers with sensitive names are removed from new History snapshots, so a re-run may require the active Environment to provide them again.

Get started

1. Install LocalMan from a trusted .vsix or its distribution page.
2. Open the LocalMan icon in the Activity Bar.
3. Expand Environments and select the included JSONPlaceholder Demo Environment.
4. Expand Collections, open JSONPlaceholder CRUD, and select one of its requests.
5. The request opens in a tab. Press Send to execute it.
6. Inspect Body, Headers, and Logs in the response area.
7. Open History to see the stored execution or choose Re-run to restore and execute it again.

JSONPlaceholder simulates write operations and does not persist changes, making it suitable for a safe first test.

Create and send a request

1. Choose LocalMan: New Request from the Command Palette, press the plus button beside the request tabs, or open LocalMan and use its initial request tab.

2. Give the request a recognizable name. This name is used in tabs, Collections, and History.

3. Select an HTTP method and enter a complete URL such as https://api.example.com/users.

4. Configure the request with the detail tabs:

   • Params adds query-string values. Disabled rows are ignored.
   • Headers adds request headers. Disabled rows are ignored.
   • Body selects and edits the request payload.
   • Auth configures Bearer, Basic, API-key, or OAuth access-token authentication.
   • Scripts runs JavaScript immediately before or after the request.

5. Select an Environment when the request contains variables such as {{baseUrl}}.

6. Press Send. While it is running, the tab displays an activity indicator and the button becomes Cancel.

7. Review the result below the request editor. A received 4xx or 5xx status is shown as a real HTTP response; DNS, timeout, cancellation, and connection problems are shown as execution errors.

[!TIP] A request created in a tab is a working draft. Select a Collection and press Save when you want to keep it permanently. Closing an unsaved tab discards that tab's draft.

Request body formats

Select Body, then choose the format that matches the API endpoint:

Format	How LocalMan sends it	Typical use
None	No request body	GET, HEAD, or endpoints without payloads
JSON	Text with Content-Type: application/json when no content type was provided	REST and GraphQL payloads
Text	Plain text exactly as entered	Text-based custom APIs
XML	XML text exactly as entered	SOAP or XML APIs
Form data	Enabled key/value rows as multipart/form-data	Simple multipart fields
URL encoded	Enabled key/value rows as application/x-www-form-urlencoded	HTML-style forms and token endpoints
Binary	Decoded from the Base64 text entered in the editor	Raw file payloads

For JSON, press Beautify JSON to parse and indent the document with two spaces. Invalid JSON is not replaced: the editor keeps the original text and displays the parsing error so it can be corrected. Beautifying only changes whitespace; it does not send the request automatically.

The Binary body mode currently expects Base64 content rather than a file-picker path. For example, a PDF or XLSX request payload must first be encoded as Base64. PDF and Excel responses do not require this step; LocalMan handles them as downloadable binary files.

Read a response

After a request completes, the response area provides:

• Body — formatted JSON, readable text/XML/HTML, an image preview, or a binary file card.
• Headers — the response headers returned by the server.
• Logs — output from pre-request and post-response scripts.
• Metadata — HTTP status, status text, duration, and response size.

Valid JSON responses use a syntax-highlighted tree with distinct colors for keys, strings, numbers, booleans, and null values. Objects and arrays can be folded individually, while Expand all and Collapse all control the complete response. If a server incorrectly returns JSON as a plain string, LocalMan also attempts to recognize and parse object or array responses without modifying their data. When parsing fails, LocalMan displays an Invalid JSON response warning with the parser error and preserves the exact response as plain text without the tree hierarchy.

PDF, XLS, and XLSX responses are recognized from their MIME type or download filename. Use Save file to choose a browser-style download, or Open PDF/Open Excel to write a sanitized temporary file and open it with the operating system's associated application. Images can be previewed inline. Other binary content is shown as a generic downloadable file.

Tabs, saved requests, and History

These three concepts serve different purposes:

Item	Purpose	Persistence
Request tab	Active working copy, response, error, cURL, and logs	Kept while the webview remains alive; closing the tab removes it
Collection request	Reusable request definition	Stored locally in collections.json
History entry	Record of an execution with its request snapshot, status, duration, and size	Latest 100 entries stored locally in history.json

Opening a Collection request creates or activates its request tab. Saving a tab into the same Collection updates the request with the same ID instead of creating duplicate copies. Selecting Re-run in History restores the stored request snapshot, opens it in Requests, and executes it again.

The close button on a tab affects only that open tab. It does not delete a request saved in a Collection. Collection deletion and History clearing use their dedicated actions.

Interface

Opening the LocalMan Activity Bar icon shows the compact Sidebar experience. The request webview includes navigation for all four LocalMan sections, while the native Collection, Environment, and History trees provide quick VS Code-style access and context actions. The author signature is a fixed footer inside the LocalMan interface; it is not an expandable About section.

Area	Purpose
Requests	Build requests, manage tabs, run scripts, generate cURL, and inspect responses
Collections	Organize saved requests and import Postman/OpenAPI files
Environments	Manage active variables and secret values
History	Review the latest executions and restore a request with Re-run
Native trees	Quickly browse and administer Collections, Environments, variables, and History

Use the Editor mode button in the Sidebar when the compact width is not enough. LocalMan opens the same complete interface as a wide VS Code editor tab, preserves the current Requests, Collections, Environments, or History section, and carries the active request draft when applicable. Repeated open actions reuse the same LocalMan editor instead of creating duplicate editor panels. The same view is available through LocalMan: Open Editor in the Command Palette.

Storage

When a workspace is open, LocalMan can store data in:

.local-man/
  collections.json
  environments.json
  history.json
  settings.json

Without a workspace—or when global mode is selected—it uses VS Code extension global storage. Writes are serialized and atomic so readers do not observe partially written JSON. Missing, outdated, or invalid files fall back safely instead of preventing activation.

Environment variables marked as secret use VS Code Secret Storage. Avoid putting credentials directly into ordinary request names, URLs, or scripts when a secret variable can be used instead.

Privacy

LocalMan does not require an account and does not include advertising, analytics, behavioral telemetry, or a LocalMan-hosted synchronization service.

Data leaves your machine only when you intentionally perform an action that requires it:

• Sending an HTTP request transmits the configured URL, headers, authentication, and body to that endpoint.
• Opening the author link opens https://www.anunknownartist.com/ in your default browser.
• Badge images in this README may be loaded by the Markdown renderer from img.shields.io.

Your API provider or target server may independently log requests according to its own policies. Local-first storage does not change the behavior of the servers you call.

Security

• Webviews use a restrictive Content Security Policy and nonce-bound scripts.
• Requests are limited to HTTP(S); request and response transfers are capped at 25 MB, and imported files at 10 MB.
• Messages from webviews are validated before sensitive operations.
• Binary filenames are sanitized again in the Extension Host.
• Temporary PDF and Excel files are constrained to the LocalMan system-temp directory. Other binaries are download-only.
• Windows-reserved names and path traversal characters are rejected or replaced.
• Script execution is time-limited, dynamic code generation is disabled, host objects are not exposed to the script context, and Restricted Mode is respected. Treat request scripts as trusted code.
• Bearer tokens, passwords, and secrets are redacted from script logs where recognizable.
• Secret Environment values use VS Code Secret Storage.
• The author footer opens one fixed HTTPS URL; the webview cannot supply an arbitrary destination.

Commands

Command	Purpose
LocalMan: New Request	Open a clean request in the full editor
LocalMan: New Collection	Create a Collection
LocalMan: New Environment	Create an Environment
LocalMan: Import cURL	Convert a cURL command into a request
LocalMan: Export cURL	Generate and copy cURL for a request
LocalMan: Run Request	Execute the active request
LocalMan: Select Environment	Select the active Environment
LocalMan: Open Editor	Open the full LocalMan workspace
LocalMan: Open Collections	Open Collections in the full editor
LocalMan: Open Environments	Open Environments in the full editor
LocalMan: Open History	Open History in the full editor
LocalMan: Open Storage Folder	Reveal the current local storage location
LocalMan: Configure Storage	Switch between workspace and global storage
LocalMan: Clear History	Remove stored History entries
LocalMan: Refresh History	Reload and synchronize History views

Native Collection and Environment items also expose inline and context-menu actions for rename, delete, and variable administration.

Languages

LocalMan follows the active VS Code display language and supports:

• English (en)
• Spanish (es)
• Simplified Chinese (zh-cn)
• Japanese (ja)
• French (fr)
• Brazilian Portuguese (pt-br)
• German (de)

Use the language selector immediately to the left of the workspace/global storage indicator to change LocalMan without reloading VS Code. The selection is saved in settings.json and synchronized between the Sidebar and full editor. On first use, LocalMan follows the active VS Code display language; unsupported locales fall back to English.

Requirements

• Visual Studio Code 1.95 or later, Kiro, or a compatible VS Code host.
• Windows is the primary supported operating system.
• Network access only when calling non-local API endpoints.
• A workspace folder only when workspace-local storage is desired.

No LocalMan account, API key, external database, or background service is required.

FAQ

Do I need to create an account?

No. LocalMan does not have an account system or mandatory cloud service.

Is LocalMan a replacement for a desktop REST client?

That is the goal for everyday API work: familiar request construction, Collections, Environments, scripts, cURL, imports, files, and History directly inside VS Code.

Does LocalMan send my Collections to a server?

No. LocalMan stores its own data locally. The requests you explicitly execute are, of course, sent to their configured target servers.

Where are secrets stored?

Environment values marked as secret use VS Code Secret Storage. Non-secret values are stored in the selected local JSON storage.

Does OAuth 2.0 perform a login flow?

Not currently. OAuth 2.0 authentication accepts an existing access token and applies it to the request.

Why does the example POST not appear in later GET results?

JSONPlaceholder simulates write responses but does not persist them.

Troubleshooting

The Sidebar does not update

• Run LocalMan: Refresh History when reviewing History.
• Close and reopen the LocalMan Activity Bar container.
• Run Developer: Reload Window after updating the extension.

A request fails before receiving an HTTP status

• Confirm the URL is valid and includes http:// or https://.
• Check DNS, proxy, VPN, firewall, and certificate configuration.
• Verify unresolved {{variables}} and the active Environment.
• Increase the timeout if the endpoint is slow.

A binary file has an unexpected name

LocalMan prefers Content-Disposition, then adds an extension inferred from the MIME type. When neither is usable, it falls back to a safe response.* filename.

Imported OpenAPI or Postman content is incomplete

LocalMan currently imports the common request, URL, query, header, and body structures. Vendor-specific extensions and advanced collection features may require manual adjustment after import.

Development

npm install
npm run check
npm run build

Press F5 in VS Code to launch an Extension Development Host. The build generates Extension Host and React webview bundles without installing a VSIX.

To create a review package:

npm run package:release

License

LocalMan is available under the MIT License included with the extension.

---

Created by An Unknown Artist.
Contact: www.anunknownartist.com