Skip to main content
Glama
This connector has been deprecated

Replaced by Control Plane.

This listing has been renamed. Control Plane is now listed as com.controlplane/mcp.

It is the same server at the same endpoint (https://mcp.cpln.io/mcp), so existing connections keep working. Please use the new listing going forward.

Write App Files

write_app_files
Destructive

Create, edit, append to, move, or delete the text files of an app you write for the user, stored on Control Plane per org and app NAME across calls and sessions; NAME is also the image and workload name. In a shell on the user's machine with a working cpln CLI (never a chat app's sandbox), prefer a directory there and cpln image build --remote --dir PATH --name NAME:TAG --org ORG, so the user keeps the code. Whole files in files, a large file in parts through appends, exact-text replacements in edits, removals in deletePaths, moves and renames (uploaded files too) in moves, at most 200 files per call. Files the user has (images, fonts, PDFs, data) never go inline: create_app_files_upload_link takes the ones that stay as they are until the next build, and content the owner changes after launch is uploaded through the app once it runs. Never include credentials or a .env with values. A Dockerfile is optional for common stacks. An app that keeps anything (content its owner changes, records, files, or sign-ins; for example a portfolio, a blog, or a shop): plan_app before the first write. Then deploy_app with the same NAME builds and runs it.

Tool call template

Replace each placeholder with a value matching the input schema. Only required parameters are included; add optional parameters as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {
      "name": "<name>"
    },
    "name": "write_app_files"
  }
}

Input Schema

NameRequiredDescriptionDefault
orgNoOrganization slug.
nameYesThe app's name, e.g. "todo-app". One name for the whole app: the `name` here, the image NAME that build_image produces (//image/NAME:TAG), and the workload name.
adoptNoConfirm that Control Plane's stored copy becomes this app's source of truth although the app was built from a repository, a folder on a machine, or an image pushed outside a Control Plane build. Only after the user asked for exactly that.
editsNoExact-text replacements in stored files (read the file first).
filesNoFiles to add or replace in full.
movesNoFiles to move or rename, uploaded ones too; nothing is sent again. Onto a stored file only if deletePaths names it.
appendsNoText added at the end of files: a large file arrives in parts, the first in `files`, the rest here.
deletePathsNoFiles to remove.

Output Schema

NameRequiredDescriptionDefault
okYes
dataNoThe full result. Read this, not only the summary.
detailsNo
summaryYes
nextStepsNo

Schema Changelog

Changes observed during successful MCP inspections.

  1. Added

TDQS

A4.8/5.0
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already flag destructiveHint=true and non-idempotency, but the description adds material context beyond them: stored state persists across sessions, moves can overwrite stored files only when deletePaths names them, edits require exact text read first, appends create missing files, and credentials/.env with values must never be written. That is real behavioral disclosure, not restatement.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Purpose is front-loaded in the first clause and every sentence carries operational content, but the middle is a dense run-on where the cpln CLI build guidance, the inline-vs-upload rule, and the file-splitting rule pile into one paragraph. It is efficient rather than tight, and a little structural separation would cost nothing.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a destructive multi-mode write tool with an output schema present, the description covers the workflow ordering, the limits, the security constraint, and the handoff to plan_app/deploy_app. Nothing an agent needs in order to invoke it safely appears to be missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so the baseline is 3; the description still earns a lift by explaining the division of labor between files, appends, edits, moves, and deletePaths, and by giving the concrete strategy for large files (first part in files, remainder in appends). It stops short of adding meaning to org and adopt, which the schema already handles well.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific set of verbs (create, edit, append, move, delete) against a specific resource (app text files stored on Control Plane per org and app NAME), plus the persistence model across calls and sessions. It also pins the relationship between the app NAME, the image name, and the workload name, so the agent knows exactly which artifact it is manipulating.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Gives explicit routing rules to siblings: binaries and user assets go to create_app_files_upload_link, planning goes to plan_app before the first write, building/running goes to deploy_app with the same NAME. It also states operating preconditions (a shell with a working cpln CLI, never a chat app's sandbox) and a hard limit of 200 files per call.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Try in Browser

Glama MCP Gateway

Add one secure layer between your agents and this server.