csvbox-mcp-server
OfficialManage CSVBox importers end-to-end from any MCP client: create and edit sheets, generate schemas/functions/integration code from prompts, validate locally, and submit files for import.
create_sheet— create a new CSVBox sheet (POST /1.1/sheet).update_sheet— full replace viaPUT; authoritative per collection, so unnamed items (and empty arrays) delete things.patch_sheet— partial merge viaPATCH; safe for applying generated functions, supports_delete: trueto remove one item.generate_sheet_json— LLM turns a natural-language prompt into a complete sheet (title,sheet_columns,destinations,webhooks,security_settings,steps); no API call.create_importer_from_prompt— prompt → generate → validate → create in a single call (aborts if no LLM key or validation fails).generate_sheet_functions— authorvirtual_columns,validation_functions, anddata_transformsjs_codefor you to review before patching; omits unrequested collections.generate_import_code— integration snippets for vanilla-js, react, vuejs2/vuejs3, angular/angular2.validate_schema— local validation of columns and function collections (caps, duplicates, references, dependency URLs, integrity), withcreate/put/patchmode rules.submit_file— available in the server schema (not the README): start an import from a public file URL, or a base64 direct multipart upload with a file name.MCP prompts
create_csvbox_sheetandcsvbox_sheet_functions— let the host client's own LLM do generation when no server-side LLM key is set (free path).Setup/runtime — stdio transport works in Claude Desktop, Cursor, Windsurf, Roo Code, Cline, VS Code, ChatGPT MCP; CSVBox credentials needed only for API-backed tools, an Anthropic/OpenAI key for prompt tools; also embeddable via exported
createServer().
Generates CSVBox importer integration code for Angular 8-13 and Angular 14+ applications.
Allows CSVBox sheet function dependencies to be loaded from the jsDelivr CDN (https-only .js/.mjs URLs with integrity digests).
Uses OpenAI models as an LLM provider to generate complete CSVBox sheet schemas and function collections from natural-language prompts.
Generates CSVBox importer integration code for React applications.
Allows CSVBox sheet function dependencies to be loaded from the unpkg CDN (https-only .js/.mjs URLs with integrity digests).
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@csvbox-mcp-server create a CSVBox importer for suppliers with columns name, GSTIN, email, phone"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
csvbox-mcp-server
A universal Model Context Protocol (MCP) server for CSVBox. It exposes CSVBox importer-sheet management as MCP tools so you can create, replace, patch, generate, validate, and scaffold importers from any MCP-compatible client — Claude Desktop, Cursor, Windsurf, Roo Code, Cline, VS Code, ChatGPT MCP, and more.
Runs over stdio, so it works the same way in every client.
Tools
Tool | Purpose | API call |
| Create a CSVBox sheet |
|
| Replace an existing sheet |
|
| Partially update a sheet |
|
| NL prompt → complete sheet JSON (via LLM) | none (calls LLM) |
| NL prompt → validate → create |
|
| Integration code (vanilla-js/react/vue/angular) | none |
| NL prompt → virtual columns / validation functions / data transforms (via LLM) | none (calls LLM) |
| Local schema validation | none |
CSVBox currently has no GET or LIST endpoints, so there are intentionally no
get_sheet/list_sheettools.
It also exposes two MCP prompts:
Prompt | Purpose |
| Make the host client's own LLM build a complete CSVBox sheet (no server-side LLM key needed). |
| Make the host client's own LLM author virtual columns, validation functions, and data transforms (no server-side LLM key needed). |
Prompt → sheet generation
generate_sheet_json and create_importer_from_prompt use an LLM to convert a free-form request into a complete CSVBox sheet — title, sheet_columns, destinations, webhooks, security_settings, and steps. Only actual data fields become columns; destinations, webhooks, domains, regions, file-upload and step settings are placed in their proper configuration sections, never turned into columns. There are three tiers:
Server LLM — when
ANTHROPIC_API_KEYorOPENAI_API_KEYis set, the server calls the LLM directly. Works in MCP Inspector and headless.MCP prompt (
create_csvbox_sheet) — when you have no server key, host clients (Cursor, Claude Desktop, Cline) run the generation with their own model, then callvalidate_schemaandcreate_sheet. Free.None configured —
generate_sheet_jsonreturns a structured "no LLM provider configured" error pointing to the MCP prompt, andcreate_importer_from_promptdoes not call the CSVBox API. There is no regex fallback.
Category / module expansion
The generator runs in one of two modes, chosen automatically from the prompt:
Extraction (default) — the prompt names concrete fields (e.g. "columns name, email, phone"). Only those become columns; nothing is invented.
Expansion — the prompt names business modules / categories as a list (e.g. "modules for: Company Information, Suppliers, Payroll, Invoice"), asks for a comprehensive/detailed schema, or asks for a column count ("at least 100 columns"). Each named module is expanded into several realistic, prefixed, correctly-typed columns (e.g. Suppliers →
supplier_id,supplier_name,supplier_gstin,supplier_email, …). An explicit minimum count is honored and everycolumn_nameis globally unique.
Data types and validations are inferred from the field names and any requested types:
Requested / implied | Column | Validators |
Dropdown / status / category with fixed options |
|
|
Percentage / percent |
|
|
Positive numeric (quantity, count, stock, cost, age) |
|
|
ID / code / reference number |
| — |
| — | |
Phone / mobile |
| — |
URL / website |
| — |
Price / cost / amount / salary |
| — |
Date fields |
|
|
Boolean / is_* / active |
| — |
GST / GSTIN / tax id |
| GSTIN pattern |
PIN code / postal code (India) |
|
|
Large schemas: the default models (
claude-haiku-4-5,gpt-4o-mini) are cheap but produce noticeably better 100+ column schemas when you override with a stronger model viaLLM_MODEL(e.g.claude-sonnet-4-6). The output cap is raised to fit big sheets; if a request is still too large the response is flaggedTRUNCATED(a distinct result, not a parse error) and the CSVBox API is not called — reduce the column count / modules or use a model with a larger output budget and retry.
Related MCP server: mcp-tabular
Function collections (virtual columns, validation functions, data transforms)
Beyond the six sheet properties, the CSVBox Sheet API accepts three collections whose items carry a js_code string that CSVBox executes during an import:
Collection | Identified by | Max |
|
|
| 20 | return the computed cell value |
|
| 10 | return an array of error strings ( |
|
| 10 | mutate the |
Inside js_code the csvbox object exposes row, column, virtual, user, import, and environment. The two accessors are not interchangeable — a virtual column is per-row and uses csvbox.row.<name> (a scalar), while a "column"-scoped function sees the whole column via csvbox.column.<name> (an array).
Shared optional fields: scope (column | row; not on virtual columns), run_at (before_validation | after_validation; data transforms only), columns / dynamic_columns, active, dependencies, and _delete (PATCH only).
Authoring them
// generate_sheet_functions (requires ANTHROPIC_API_KEY or OPENAI_API_KEY)
{
"prompt": "add a virtual column joining first and last name, and check every email contains an @",
"sheet": { "title": "Customers", "sheet_columns": [ ... ] }
}Returns { "virtual_columns": [...], "validation_functions": [...], "source": ..., "validation": {...} }. Collections the request does not imply are omitted, never returned as empty arrays.
This tool does not call the CSVBox API. Read the generated js_code, then apply it yourself with patch_sheet. Pass sheet so the model references real column names and the validator can check those references — CSVBox has no read endpoint, so it must be supplied inline. Without an LLM key, use the csvbox_sheet_functions MCP prompt instead.
PUT vs PATCH — read this before applying
|
| |
Collection you send | authoritative — any existing item not named is deleted | merged — unnamed items are left alone |
| deletes all 20 | no-op |
Key omitted | untouched | untouched |
| not valid | removes that item (all its other fields ignored) |
Use patch_sheet to apply generated functions. Validate first with the matching verb:
// validate_schema
{ "sheet": { "data_transforms": [ ... ] }, "mode": "patch" }mode is create (default), put, or patch. It only affects the function collections — under put an empty array is a hard error rather than a warning, and _delete is rejected outside patch.
Dependencies
An item may load up to 5 third-party scripts:
{ "url": "https://cdn.jsdelivr.net/npm/dayjs@1.11.10/dayjs.min.js",
"globals": ["dayjs"],
"integrity": "sha384-..." }Only cdn.jsdelivr.net, unpkg.com, and cdnjs.cloudflare.com are allowed; https only, .js/.mjs path, no query string, fragment, userinfo, or port.
Security. This server never executes
js_code— it is an opaque string here. Generated JavaScript is unreviewed model output, so read it before you PATCH it into a live importer. A dependency without anintegritydigest can change under your customers at any time;validate_schemawarns when one is missing.
See docs/sheet-functions-example.json for a full payload.
Installation
npm install @csvbox/mcp-serverOr build from source:
git clone <this-repo> csvbox-mcp-server
cd csvbox-mcp-server
npm install
npm run buildThis produces dist/index.js — the entrypoint MCP clients launch.
Environment variables
Copy .env.example to .env and fill in your CSVBox credentials:
CSVBOX_API_KEY=your_api_key
CSVBOX_API_SECRET=your_api_secretCSVBox credentials are only required for the API-backed tools (create_sheet, update_sheet, patch_sheet, create_importer_from_prompt). validate_schema and generate_import_code work without any credentials.
Auth header note: the client sends
x-csvbox-api-keyandx-csvbox-secret-api-key(matching the CSVBox reference payloads). These are defined as constants insrc/services/csvbox-api.tsif your account uses different header names.
Client identification
Every request this server sends to the CSVBox API carries two extra headers:
x-csvbox-client: mcp
x-csvbox-client-version: <the version in package.json>CSVBox records how each sheet was created; without these, sheets and imports made through MCP are indistinguishable from any other REST caller. The version is read from package.json and is the same one the server advertises to your MCP client, so the two can never disagree.
These are always sent — there is no environment variable or tool input that disables or changes them. They carry no credentials and nothing derived from your tool inputs. Tools that make no API call (generate_sheet_json, generate_sheet_functions, generate_import_code, validate_schema) send no request and therefore no headers.
LLM provider (for prompt → sheet generation)
generate_sheet_json and create_importer_from_prompt need an LLM. Set one of:
ANTHROPIC_API_KEY=sk-ant-...
OPENAI_API_KEY=sk-...The provider is auto-detected:
Condition | Provider | Default model |
| Anthropic |
|
| OpenAI |
|
| Anthropic |
|
| OpenAI |
|
neither key set | none — tools return an error pointing to the | — |
LLM_PROVIDER disambiguates when both keys are present; LLM_MODEL overrides the model for whichever provider is chosen. For large category/module schemas (100+ columns) set LLM_MODEL to a stronger model (e.g. claude-sonnet-4-6) — see Category / module expansion.
MCP Inspector: set the LLM key in the Inspector's environment-variables panel to use the server-LLM path. Inspector has no host LLM of its own, so it can render the
create_csvbox_sheetprompt but cannot execute it — for the keyless path use a client with a model (Cursor, Claude Desktop, Cline).
Running locally
# After building:
npm start
# Or run the built file directly:
node dist/index.jsThe server speaks MCP over stdio and logs csvbox-mcp-server running on stdio to stderr (stdout is reserved for the protocol).
Client configuration
For a published installation, use the npm package with npx. Set CSVBOX_API_KEY / CSVBOX_API_SECRET in the env block.
Note: The npm package is
@csvbox/mcp-serverand the executable iscsvbox-mcp-server.
Claude Desktop
Add the following to your Claude Desktop MCP configuration:
{
"mcpServers": {
"csvbox": {
"command": "npx",
"args": [
"-y",
"--package=@csvbox/mcp-server",
"csvbox-mcp-server"
],
"env": {
"CSVBOX_API_KEY": "your_api_key",
"CSVBOX_API_SECRET": "your_api_secret"
}
}
}
}Cursor
Edit ~/.cursor/mcp.json (global) or .cursor/mcp.json (per-project):
{
"mcpServers": {
"csvbox": {
"command": "npx",
"args": [
"-y",
"--package=@csvbox/mcp-server",
"csvbox-mcp-server"
],
"env": {
"CSVBOX_API_KEY": "your_api_key",
"CSVBOX_API_SECRET": "your_api_secret"
}
}
}
}Windsurf
Edit ~/.codeium/windsurf/mcp_config.json:
{
"mcpServers": {
"csvbox": {
"command": "npx",
"args": [
"-y",
"--package=@csvbox/mcp-server",
"csvbox-mcp-server"
],
"env": {
"CSVBOX_API_KEY": "your_api_key",
"CSVBOX_API_SECRET": "your_api_secret"
}
}
}
}Roo Code
In the Roo Code MCP settings (mcp_settings.json):
{
"mcpServers": {
"csvbox": {
"command": "npx",
"args": [
"-y",
"--package=@csvbox/mcp-server",
"csvbox-mcp-server"
],
"env": {
"CSVBOX_API_KEY": "your_api_key",
"CSVBOX_API_SECRET": "your_api_secret"
}
}
}
}Cline
In the Cline MCP settings (cline_mcp_settings.json):
{
"mcpServers": {
"csvbox": {
"command": "npx",
"args": [
"-y",
"--package=@csvbox/mcp-server",
"csvbox-mcp-server"
],
"env": {
"CSVBOX_API_KEY": "your_api_key",
"CSVBOX_API_SECRET": "your_api_secret"
}
}
}
}VS Code MCP
Add to .vscode/mcp.json (or the global mcp.json):
{
"servers": {
"csvbox": {
"command": "npx",
"args": [
"-y",
"--package=@csvbox/mcp-server",
"csvbox-mcp-server"
],
"env": {
"CSVBOX_API_KEY": "your_api_key",
"CSVBOX_API_SECRET": "your_api_secret"
}
}
}
}Example tool calls
Generate a complete sheet from a prompt (LLM, no CSVBox API call):
// generate_sheet_json (requires ANTHROPIC_API_KEY or OPENAI_API_KEY)
{ "prompt": "Create employee importer with name, email, salary, joining date; destination as testapi; allow only xlsx files" }Returns { "sheet": { "title": ..., "sheet_columns": [...], "destinations": [...], "steps": {...} }, "source": "llm:anthropic:claude-haiku-4-5", "validation": { "valid": true, ... } }. Data fields become columns (salary → currency, joining date → date); the destination and xlsx setting go to destinations / steps, not columns. With no LLM key, returns an error pointing to the create_csvbox_sheet prompt.
Validate a schema before sending it:
// validate_schema
{ "sheet": { "title": "Customers", "sheet_columns": [
{ "column_name": "email", "display_label": "Email", "type": "email" }
] } }Returns { "valid": true, "errors": [], "warnings": [ ... ] }.
Create a sheet:
// create_sheet
{ "sheet": { "title": "Customer Import", "sheet_columns": [
{ "column_name": "name", "display_label": "Name", "type": "text" },
{ "column_name": "email", "display_label": "Email", "type": "email" }
] } }Generate + create in one step:
// create_importer_from_prompt (requires an LLM key + CSVBox credentials)
{ "prompt": "Create customer importer with name, email, phone; allow for example.com" }Returns { "generated_schema": { ... }, "source": ..., "validation": { ... }, "api_response": { ... } }. Aborts without calling the API if no LLM provider is configured or the generated schema fails validation.
Replace a sheet:
// update_sheet
{ "sheet_license_key": "abc123", "sheet": { "title": "Updated", "sheet_columns": [ ... ] } }Destructive for any collection you send — see PUT vs PATCH.
Patch a sheet:
// patch_sheet
{ "sheet_license_key": "abc123", "changes": { "title": "New Title" } }Remove one function without touching the rest:
// patch_sheet
{ "sheet_license_key": "abc123",
"changes": { "virtual_columns": [ { "column_name": "full_name", "_delete": true } ] } }Generate integration code:
// generate_import_code
{ "framework": "react" }Supported column types
text, number, email, date, time, boolean, regex, ip, url, credit_card, phone_number, currency, list, dependent_list, dynamic_list, dependent_dynamic_list, multiselect_list, multiselect_dynamic_list.
Development
npm run build # compile TypeScript → dist/
npm start # run the built server
npm run lint # type-check without emitting
npm test # compile and run the unit suite (alias: npm run test:unit)Tests
npm test compiles src/tests/ and runs it with Node's built-in test runner — no
test framework, no mocking library.
The suite is hermetic. It never contacts an external host, never reads your
ambient CSVBOX_API_* / ANTHROPIC_API_KEY / OPENAI_API_KEY, and never touches
a real CSVBox account, so it passes identically whether or not you have
credentials configured. HTTP is intercepted at the axios adapter; the LLM is a
scripted fake; the one test that needs real request encoding starts an ephemeral
listener on 127.0.0.1 and closes it afterwards. Tests that read environment
variables set what they need explicitly and restore the previous values.
E2E tests
npm run test:e2e # run the Playwright suite
npm run test:e2e:report # open the HTML report from the last runSpecs live in e2e/, configured by playwright.config.ts. Like the unit suite,
this suite is hermetic: it starts mock CSVBox and LLM servers on loopback
(e2e/support/mock-csvbox-server.ts, e2e/support/mock-llm-server.ts) and
drives the real built server (dist/index.js) through MCP Inspector with
fake credentials pointed at those mocks — it never contacts a real CSVBox
account or LLM provider, and never reads your .env. A separate,
zero-credential Inspector instance covers the "missing credentials" error
paths. Requires npm run build first (the test:e2e webServer entries build
automatically).
Embedding the server
createServer() is exported from the entry module. It registers every tool and
prompt and returns the McpServer without attaching a transport, so you can
connect it to one of your own:
import { createServer } from "@csvbox/mcp-server";
const server = createServer();
await server.connect(myTransport);Importing the module does not start anything; the stdio server runs only when
dist/index.js is executed directly.
License
MIT
Available Tools
9 toolscreate_importer_from_promptCreate Importer From PromptA
Generate a COMPLETE CSVBox sheet from a natural-language prompt via a configured LLM, validate it locally, then create it via POST /1.1/sheet. Returns { generated_schema, source, validation, api_response }. Aborts (no API call) if no LLM provider is configured or if validation fails. Requires ANTHROPIC_API_KEY or OPENAI_API_KEY plus CSVBox credentials.
Inputs: prompt (required).
create_sheetCreate CSVBox SheetC
Create a new CSVBox sheet via POST /1.1/sheet. Input: { sheet }. Returns the API response.
Inputs: sheet (required).
generate_import_codeGenerate CSVBox Integration CodeA
Generate complete CSVBox importer integration code for a framework (vanilla-js, react, vuejs2 [Vue 2], vuejs3 [Vue 3], angular [Angular 8-13], angular2 [Angular 14+]). Input: { framework }. Replace the license key placeholder with your sheet's license key.
Inputs: framework (required).
generate_sheet_functionsGenerate CSVBox Sheet FunctionsA
Author CSVBox virtual_columns, validation_functions, and data_transforms from a natural-language prompt using a configured LLM. Does NOT call the CSVBox API — it returns JSON so you can REVIEW the generated JavaScript before applying it with patch_sheet. Collections the request does not imply are omitted, never returned as empty arrays. Returns { virtual_columns?, validation_functions?, data_transforms?, source, validation }. Requires ANTHROPIC_API_KEY or OPENAI_API_KEY; without one it returns an error pointing to the csvbox_sheet_functions MCP prompt. Input: { prompt, sheet? }.
Inputs: prompt (required), sheet.
generate_sheet_jsonGenerate CSVBox Sheet JSONA
Generate a COMPLETE CSVBox sheet (title, sheet_columns, destinations, webhooks, security_settings, steps) from a natural-language prompt using a configured LLM. Does NOT call the CSVBox API. Returns { sheet, source, validation }. Requires ANTHROPIC_API_KEY or OPENAI_API_KEY; without one it returns an error pointing to the create_csvbox_sheet MCP prompt. Input: { prompt }.
Inputs: prompt (required).
patch_sheetPatch CSVBox SheetA
Partially update a CSVBox sheet via PATCH /1.1/sheet/{sheet_license_key}. Sends only the changes object. Input: { sheet_license_key, changes }. Returns the API response. PATCH MERGES: only the items you list are touched and nothing is deleted implicitly, so an empty array is a no-op. Items in virtual_columns, validation_functions and data_transforms are matched by column_name / function_name / transform_name respectively — an unmatched name creates a new item. To remove one, send it with _delete: true; every other field on a _delete item is ignored, including js_code. This is the safe verb for applying generated functions. Run validate_schema with mode 'patch' first.
Inputs: changes (required), sheet_license_key (required).
submit_fileSubmit File via CSVBox REST File APIA
Submit a file for import via POST /1.1/file. Provide exactly one of public_file_url (JSON submission) or file_base64 + file_name (multipart direct upload — file_base64 is decoded server-side and sent to CSVBox as true binary multipart content, never as a base64 string). Input: { sheet_license_key, public_file_url? | (file_base64?, file_name?), file_sheet_name?, user?, options?, dynamic_columns? }. Returns the API response.
Inputs: sheet_license_key (required), user, options, file_name, +4 more.
update_sheetUpdate (Replace) CSVBox SheetA
Replace an existing CSVBox sheet via PUT /1.1/sheet/{sheet_license_key}. Input: { sheet_license_key, sheet }. Returns the API response. DESTRUCTIVE: PUT is authoritative for every collection it sends — items listed are created or updated in place, and any existing item the array does not name is DELETED. This applies to virtual_columns, validation_functions and data_transforms: sending an empty array DELETES ALL of that collection's items, while OMITTING the key leaves them untouched. _delete is not valid here; use patch_sheet to remove a single item. Run validate_schema with mode 'put' first to catch a destructive body.
Inputs: sheet (required), sheet_license_key (required).
validate_schemaValidate CSVBox SchemaA
Validate a CSVBox sheet schema locally (no API call). Requires a non-empty title; sheet_columns is optional (absent passes, empty yields a warning). When columns are present, checks for missing column_name/display_label/type, unsupported types, duplicate names, duplicate positions, and invalid dependent column references. Also checks virtual_columns, validation_functions, and data_transforms: per-sheet caps, duplicate and colliding names, missing or oversized js_code, scope/run_at enums, column references against sheet_columns, and dependency URLs (https, allowed CDN hosts, .js/.mjs, integrity digest). Pass mode ('create' | 'put' | 'patch', default 'create') so empty-array and _delete rules match the verb you are about to use. Returns { valid, errors, warnings }.
Inputs: sheet (required), mode.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 9 tools
Tools are mostly distinct: create/update/patch/validate/submit/generate each target different actions. The three 'generate_' tools produce different outputs (sheet JSON, code, functions), but 'create_importer_from_prompt' and 'generate_sheet_json' both involve prompt-based sheet generation, with the former actually creating while the latter only returns JSON, which could cause minor confusion.
Most names follow a verb_noun pattern (create_sheet, update_sheet, patch_sheet, validate_schema, submit_file, generate_sheet_json, generate_import_code, generate_sheet_functions). The exception is 'create_importer_from_prompt', which uses 'importer' instead of the more consistent 'sheet' and breaks the pattern slightly.
With 9 tools, the surface is well-scoped for a CSV import integration server. Each tool covers a distinct aspect (schema creation, modification, validation, file submission, and generation helpers) without redundancy, and the count fits comfortably in the ideal range.
The set covers create, update (PUT/PATCH), validation, and file submission, but lacks read operations (e.g., get_sheet, list_sheets) and explicit sheet deletion. While patch supports _delete, there is no direct delete_sheet tool. This creates a gap for agents that need to inspect or manage existing sheets outside of updates.
Maintenance
Related MCP Connectors
Remote MCP: JSON repair, JSON Schema validation, JSON to TypeScript, CSV to JSON and JSON to CSV.
Manage Pipefork API projects, drafts, connections, secrets, and deployments through MCP.
Create and manage trading strategies, bots, webhooks and signals from any MCP client.
Related MCP Servers
- FlicenseAqualityDmaintenanceEnables comprehensive CSV file management including creating, editing, analyzing, and transforming CSV data anywhere in the filesystem. Provides statistical analysis, data validation, filtering, and grouping capabilities through MCP protocol over stdio transport.15-
- AlicenseBqualityDmaintenanceEnables SQL querying over CSV and Excel files using DuckDB, providing tools to load files, inspect schemas, and run read-only queries via MCP.5MIT
- FlicenseNot gradedqualityDmaintenanceMCP server that exposes Google Sheets as read-only resources, providing static and templated URI access to sheet data as CSV.-
- AlicenseNot gradedqualityCmaintenanceEnables reading, writing, appending, and creating Google Sheets spreadsheets through MCP tools, with support for exploring spreadsheet structure and creating new sheets.86 npmMIT