Skip to main content
Glama
Flisk App Builder

Flisk App Builder

Official

Server Configuration

Describes the environment variables required to run the server.

NameRequiredDescriptionDefault

No arguments

Instructions

Guidance the server publishes about itself, which clients place ahead of the tool catalog so the model reads it before choosing anything.

This server publishes no instructions, or was last inspected before Glama recorded them.

Capabilities

Features and capabilities supported by this server

Protocol revision2025-11-25

CapabilityDetails
tools
{
  "listChanged": false
}

Tools

Functions exposed to the LLM to take actions

NameDescription
doctorA

Check whether this machine can run the Flisk stack (Docker, Tilt, ports). Read-only. Optionally set projectPath to include checks for a specific Flisk project. Returns data.ready and data.host.canUp; run it before up. For the state of a running stack use status; for whether generated files are consistent use config_verify.

upA

Start the stack (or part of it) detached from the optional projectPath. The result carries state: ready (every local-process service passed its readiness check), starting (launched, readiness not confirmed: the default after a short wait; poll status, or pass waitForReady), failed (a service exited or gave up; the error carries its own output) or timeout (waitForReady was set and readiness was not reached in waitSeconds; it keeps starting). started: true never means ready. Fails fast on an unknown service, an unsupported host, or a Tilt already running.

downA

Stop the running stack, optionally selecting its project with projectPath. It stops the running services and does not edit the project's files. Use status first to see whether a stack is running, set dryRun to preview, and start it again with up.

statusA

Show the live state of the stack: its stacks, resources, their ingress URLs and container ports, the stack-level ports, and Tilt readiness (data.tilt.readiness: ready, pending, failures, enabled; null when no Tilt answers). Read-only. Poll it after up. For the services a project defines whether or not they run use resource_list; for URLs only use network_list; for host checks use doctor. Optionally select the project with projectPath.

logsA

A bounded snapshot of recent logs from the running stack (default the last 200 lines, at most 10000), returned as text. Read-only. Optionally select the project with projectPath. Not a stream: call it again for newer lines. Use status first to find which service is failing, then pass services to narrow the output and source runtime to skip image build output and read why it failed.

resource_listA

List the selected project's services (resources) with their stack, type and port, whether or not they are running. Read-only. Use status for live state, stack_list to group them by stack and agent_list for agents only. Set projectPath when the MCP server is not running from the project root.

resource_restartA

Restart one running resource in the stack along with any active container resources that transitively declare sidecarOf on it (Flisk-generated Compose containers restart without rebuilding their image; local-process resources of a project that runs without Tilt are restarted by the run that supervises them (its .env is re-read, only that service is stopped and started, and the result says whether it is ready, failed with its own output, or still starting); other non-container resources and projects using an imported Tiltfile fall back to tilt trigger); unrelated resources are not touched. It needs a running stack: start one with up. Set rebuild to true for a full Tilt update (rebuild the image and recreate the container, which re-reads the project .env). Names come from resource_list. Set projectPath when the MCP server is not running from the project root.

resource_runA

Run a one-off command (a seed script, a migration, a status check) with the environment one resource has in the stack, and return its exit code, stdout and stderr (the last 64 KB of each; values from the project's .env files are masked). It runs any command, so it is refused unless confirm is true: ask the user first. A container resource must be running (start it with up); a local-process resource runs from its folder. No input is passed. Names come from resource_list. Set projectPath when the MCP server is not running from the project root.

agent_listA

List AI agent resources (appType: 'agent') in the project with their stack, runtime, durability and port. Read-only. Use resource_list for every resource type, and agent_sessions to inspect one agent's sessions. Set projectPath when the MCP server is not running from the project root.

agent_sessionsA

List the sessions of a running AI agent resource (id, last activity, status, checkpoint size), or read one session's checkpoint when sessionId is set. Set projectPath when the MCP server is not running from the project root.

stack_listA

List the project's stacks with their resource counts. Read-only. Use resource_list for the resources themselves. Set services to include each stack's service names, and verbose for its description. Set projectPath when the MCP server is not running from the project root.

project_infoA

Project root, whether the generated master files exist (data.configured, data.missingFiles), and resource and stack counts. Read-only; a quick first call to learn whether a folder is a configured Flisk project. Use config_verify to check that the generated files match, and status for the running stack. Set projectPath when the MCP server is not running from the project root.

project_templatesA

List the starter templates project_init can clone (data.templates): each one's key, repo, description and, for a template pinned to a commit, the ref it checks out. Read-only; the same rows as flisk project --list --json. Pass a key as project_init's template.

network_listA

The Traefik URL of every frontend and API service, with its base path, port and whether it answers (running, stopped). Read-only. Use it to find where to open a service; use status for full readiness. Set projectPath when the MCP server is not running from the project root.

config_verifyA

Check that the generated files match .flisk/project.json and that every service.json is valid. Returns data.valid, data.errors, data.warnings and data.diffs; a drifted generated file is fixed with config_regenerate. Set projectPath when the MCP server is not running from the project root.

config_explainA

Explain one project file: whether Flisk generated it or the user owns it, its source, whether it is edited now, whether editing it blocks up, and what to edit instead. Run it before editing a file you did not write. Set projectPath when the MCP server is not running from the project root.

runtime_checkA

Read-only. Check that the installed Flisk CLI has its bundled runtime assets (engine, templates). Returns ok, assetRoot and what is missing; a source checkout reports ok: false because the assets exist only in a packaged install. projectPath is optional: a project-local install under its node_modules is checked too.

config_regenerateA

Regenerate the master config files in .flisk/.flisk-out/ from .flisk/project.json. A dry run by default, which returns the planned changes as data.changes (each file's status and lineDiff) with data.hasChanges; set dryRun to false to write them and get the same list, which discards hand edits in those generated files. Set projectPath when the MCP server is not running from the project root.

resource_createA

Scaffold a new service (service.json, Dockerfile, source and a test) with flisk resource <name> --yes, or register an existing directory that already has a service.json. Returns the command's text output. Without stack it uses the only existing stack or main, and fails when several stacks exist. Do not call it again for a resource that already exists: that rewrites its service.json and can assign it a new port (check with resource_list first). Call up afterwards to start it. Set projectPath when the MCP server is not running from the project root.

tool_addA

Add a tool by its everyday name (react, nextjs, fastapi, nodejs, postgresql, mysql, mongodb, rag, embeddings, llm-api) with flisk tool add <tool> --json, which runs the matching flisk resource command. data.status says what happened: resource (created; data.resource is the resource_create result), built-in (docker: nothing to do), manual (angular, tailwind, spring-boot, github-actions, jutro, policycenter: data.steps are steps to show the user; nothing was changed), or an error for a rejected tool (aws, google-cloud, azure, kubernetes): Flisk runs everything locally and never creates cloud resources, so do not work around it. Call up afterwards to start a new resource. Set projectPath when the MCP server is not running from the project root.

stack_assignA

Assign resources that have no stack yet to a stack (writes stack into their service.json). A resource already in a stack is refused unless move is true, which moves it out of its current stack. Returns the structured envelope: data.stack and data.assigned (name and service.json path of each resource), or errors with a code and suggestions (for example the valid resource names). Set projectPath when the MCP server is not running from the project root.

project_initA

Create a Flisk project with flisk project --yes: in projectPath (an existing directory; default the server's directory) write .flisk/project.json and generate its files, or, with template, clone a starter project into a new directory there (then call project_init again with projectPath set to the clone to configure it). Inside an existing project it refreshes that project's generated files instead and never overwrites its project.json. Returns the command's text output.

project_ejectA

Write EJECTED.md with flisk eject --json: it lists the generated Tilt files and how to run the stack with plain Tilt, and copies, moves or deletes nothing. It changes the project, so it is refused unless confirm is true; dryRun returns the plan (data.generatedFiles, data.created) without confirm. Set projectPath when the MCP server is not running from the project root.

project_importA

Import the services in a directory's root docker-compose.yml as bring-your-own service.json files with flisk import --json, which runs the pinned flisk-import from npm (the first run needs network access). It writes without asking: set dryRun to get the plan only, and force to overwrite an existing service.json (force needs confirm: true unless dryRun is set). Returns data.written and the importer's output. Set projectPath when the MCP server is not running from the project root.

Prompts

Interactive templates invoked by user choice

NameDescription

No prompts

Resources

Contextual data attached and managed by the client

NameDescription

No resources

TDQS

A4.1/5.0

Scored across 24 tools

Disambiguation4/5

The set has several look-alike families (status/resource_list/network_list/stack_list/agent_list/project_info, and doctor/runtime_check/config_verify), but the descriptions explicitly cross-reference each other with 'use X for Y' guidance, which resolves most confusion. A few boundaries (doctor vs runtime_check, project_info vs config_verify) still require careful reading.

Naming Consistency4/5

The dominant convention is noun_verb (project_init, resource_create, config_regenerate, stack_assign, agent_sessions, network_list), applied to 19 of 24 tools. The remaining five are bare lifecycle verbs (up, down, status, logs, doctor), which is a deliberate and readable deviation but not fully uniform.

Tool Count4/5

24 tools is on the heavy side, but the domain is genuinely broad: project scaffolding/import/eject, config generation and verification, stack lifecycle, resource management, agents, and host checks. Nearly every tool maps to a distinct operation, though a few (project_templates, config_explain, runtime_check) are niche.

Completeness3/5

Creation and inspection are well covered (project_init/import, resource_create, tool_add, up/down/restart/run), but there is no delete or remove operation for resources or stacks, no per-service stop, and agent tooling is read-only (list/sessions) with no lifecycle control. These gaps will force agents to fall back to raw CLI calls.

Maintenance

ActivityActive
ResponsivenessSyncing