floot

{
  "id": "aix_2fa0f70599",
  "name": "floot",
  "operator": "(unclaimed - source: registry-official · publisher: com.floot)",
  "description": "Build and publish full-stack web and mobile apps on Floot from any MCP client. Building is free.",
  "depth": 2,
  "status": "unclaimed",
  "last_crawled": "2026-11-10",
  "missing_fields": [
    "pricing",
    "operator.identity"
  ],
  "skills": [
    "browser-automation",
    "sql-database",
    "text-to-image"
  ],
  "protocols": {
    "mcp": "https://mcp.floot.com/mcp",
    "a2a": null
  },
  "pricing": null,
  "regions": [
    "global"
  ],
  "languages": [
    "en"
  ],
  "reputation": {
    "tasks_completed": null,
    "dispute_rate": null,
    "p95_latency_ms": 2952,
    "uptime_30d": 1,
    "onchain_volume_30d_usd": null
  },
  "aix_score": 41,
  "verification": {
    "identity": "none",
    "health": "probe/24h",
    "pricing": "unknown",
    "last_check": "2026-11-10T11:00:42.655Z"
  },
  "pricing_model": "unknown",
  "links": [
    {
      "label": "homepage",
      "url": "https://floot.com/"
    }
  ],
  "unreachable": false,
  "profile": {
    "mcp_server": "floot",
    "mcp_version": "1.0.0",
    "tool_count": 47,
    "tools": [
      {
        "name": "search",
        "description": "Search your Floot projects and their code. Returns result ids usable with fetch. For richer options, list_projects enumerates projects and search_code does code-level search."
      },
      {
        "name": "fetch",
        "description": "Fetch a search result by id: a project overview ('<projectId>') or a file ('<projectId>:<path>'). For direct access to a known file or project, read_file/list_files give more detail."
      },
      {
        "name": "list_projects",
        "description": "List your Floot projects (id, name, last-updated, whether an app icon is set), most recently updated first. name_filter is a case-insensitive substring match on the stored name, which is often not the name the user uses for a project — on a small account a filter that matches nothing returns the whole list instead."
      },
      {
        "name": "list_resources",
        "description": "List the env vars a project's code can use and the resources behind them: (1) resources CONNECTED to the project — usable as process.env.<NAME> in endpoint code now; (2) the owner's other account-level credentials — reusable, but not usable in code until connected; (3) everything Floot can add. Call it to learn what env vars exist before writing backend code, and BEFORE provisioning or requesting any credential (the owner may already have the one you need). Pass query (case-insensitive substring over names, descriptions, types, and env var names) to filter when the account has many resources. "
      },
      {
        "name": "list_files",
        "description": "List a Floot project's virtual file tree with sizes, plus its dependencies, current version (pass the version to write tools as expected_version), and current project metadata — title, description, app icon (iconUrl), splash screen, mobile app id, SSR, iOS Info.plist overrides, share target (iOS + Android), native system bars. This is where to look up those settings; update_project_metadata changes them."
      },
      {
        "name": "read_file",
        "description": "Read a file from a Floot project (cat -n style); offset/limit for large files. Paths: components/Name.tsx, components/Name.module.css, helpers/Name.tsx, pages/name.tsx, pages/name.pageLayout.tsx, endpoints/route_POST.ts, endpoints/route_POST.schema.ts, static/file.txt, base.css. include_references:true also lists the files that reference this one (imports, queueTask/runCode names, endpoint URL strings): check it before renaming or deleting, or use rename_file, which rewrites importers. Hosted assets read too (/_cdn/<name> as upload_asset / generate_image return it, private/<name>): png/jpeg/gi"
      },
      {
        "name": "read_files",
        "description": "Read up to 20 files in ONE call, much cheaper than repeated read_file: prefer it whenever you need several files together (an endpoint, its .schema.ts and the hook that calls it). Same paths and options as read_file (diagnostics, include_references; /_cdn/<name> images come back as images), each file cat -n style under a header. Output is capped: whole files at the end are left out and listed by name. With older_than (up to 5 paths) the files are walked back through history TOGETHER on one timeline — the way to keep a component and its stylesheet consistent."
      },
      {
        "name": "search_code",
        "description": "Search a Floot project's files (string or regex) with optional glob filters (e.g. ['components/*', 'endpoints/**']). Returns file:line excerpts plus filename matches; capped at 40 results."
      },
      {
        "name": "get_guides",
        "description": "Floot documentation for agents. Call with no arguments to list available guides. Pass `topic` for one guide (e.g. topic:'floot-overview') or `topics` (an array of ids) to fetch several at once. floot-overview explains how Floot projects work — read it before your first code change. Skill guides that ship seed code (marked in the list) AUTO-INJECT it into the project the first time they're loaded with a projectId — pass projectId whenever you're working on a project; idempotent, never overwrites existing files."
      },
      {
        "name": "write_file",
        "description": "Create or fully overwrite a file in a Floot project. Content is written literally. Paths must follow the item scheme (see read_file); invalid paths are rejected with the rule they broke. Pass expected_version (from list_files/read_file) to detect concurrent edits. Writing components/Name.module.css sets the css of components/Name — other properties of the item are preserved."
      },
      {
        "name": "edit_file",
        "description": "Replace old_string with new_string in a project file. old_string must match the current content exactly (including whitespace) and be unique unless replace_all is set. Prefer this over write_file for changes to existing files."
      },
      {
        "name": "delete_file",
        "description": "Delete a project file. Deleting an item's main code file (e.g. components/Foo.tsx) removes the whole item including its css/tests; deleting an aux file (e.g. Foo.module.css) only clears that part."
      },
      {
        "name": "remove_dependency",
        "description": "Remove npm packages from a Floot project's dependency record (record-only; nothing runs)."
      },
      {
        "name": "create_project",
        "description": "Create a new Floot project (pre-seeded with the shared component library) and return its id. `initial_prompt` describes the app to build — what it does and for whom — keeping the user's own wording where they gave one rather than a summary. It becomes the project's system prompt (static/__dev/system-prompt.md, which the user can edit) and grounds the project (served back as <project-instructions> in list_files). The result renders a live preview card for the user and includes the first-build playbook: a fresh project is EMPTY until pages are written, so a session normally continues straight in"
      },
      {
        "name": "apply_patch",
        "description": "Apply a V4A patch to a Floot project — create and update multiple files in ONE atomic operation. Format: \"*** Begin Patch\" envelope with \"*** Add File: path\" (+ prefixed lines) and \"*** Update File: path\" (hunks: optional \"@@ anchor\" locator, space-prefixed context, -/+ lines, optional \"*** End of File\"), then \"*** End Patch\". Paths follow the Floot item scheme (see read_file). To replace a file wholesale use Add File on its own path; the item's other files (e.g. its .module.css) are kept. This tool does not delete or rename: \"*** Delete File:\" sections are skipped and listed in the result (de"
      },
      {
        "name": "get_logs",
        "description": "Your FIRST step when debugging any runtime problem (a 500, a failed request, a blank page, 'it doesn't work'): call it before theorizing from an error message. Sources:\n- 'server' (default): the dev backend's request logs from the last hour (method, URL, status, duration, server log lines), background jobs included; pass log_reference_id for one request's full logs.\n- 'browser': console output and client-side network requests (`⇄ METHOD url → status`, with the error body of failed ones: CORS, timeouts, third-party calls) from the user's open editor session; empty if none is open. A line's `ref"
      },
      {
        "name": "typecheck",
        "description": "Typecheck the project (incremental tsc on the project VM). Type errors don't block the app from running."
      },
      {
        "name": "run_tests",
        "description": "Run the project's Jasmine specs (helpers/*.spec.tsx) on the project VM (jsdom): specs may render components (@testing-library/react) or call endpoint handlers and backend helpers directly. Limits: fetch throws inside tests (mock with spyOn(globalThis, \"fetch\")), process.env secrets are absent (give a module that reads one at load a dummy value from a helper the spec imports BEFORE it, e.g. helpers/testEnv.tsx setting process.env.JWT_SECRET = \"test-secret\"; env is reset per spec file), spyOn cannot replace an exported function of a project module (pass dependencies in as arguments instead), no "
      },
      {
        "name": "add_dependency",
        "description": "Add npm packages to the project (validated against Floot's supported set — rejected packages get a supported alternative named; some versions are pinned/substituted). Avoid node-gyp/native packages (exception: sharp is supported, auto-pinned), WASM modules, and packages bundling large binaries (e.g. ffmpeg/ffprobe); pure JS/TS preferred. A bare `kysely` keeps the version the project already records (a project without one gets 0.28.17), the version its db/schema helpers are written against; pass an explicit `kysely@<version>` only when upgrading it deliberately. Installs on the project VM and p"
      },
      {
        "name": "run_code_in_vm",
        "description": "Run a Node.js snippet on the project's compute VM and return its stdout and stderr. ESM by default (a bare require() snippet runs as CJS). The project's npm dependencies are importable and the network works, so a snippet can call the project's /_api/* endpoints (get_preview_url → apiBaseUrl). The project's env vars, secrets and source files are not available.\n\nFor data too large to pass through the conversation (an uploaded CSV, images, usage and log history), a `_floot` global works on this project only:\n- `runSQLQuery({ query, reasonAndExplanationForNotReadOnly? })`: runs SQL on the project'"
      },
      {
        "name": "run_code_in_browser",
        "description": "Run a TypeScript snippet inside the running app's preview document in the user's open Floot editor and return the string it returns. `document` and `window` are the app's own DOM: measure elements, read computed styles and rendered output, or click a button and read the result. Runs at the project root, so project files import by relative path, and browser APIs (canvas, createImageBitmap, WebGL) work. A `_floot` global has `storageUpload({ filename, contentType, sizeBytes })` to save a file the page made (e.g. a canvas as a PNG: it returns a presignedUrl to PUT the bytes to and the file's url)"
      },
      {
        "name": "delete_storage_file",
        "description": "Delete files from the project's storage (what the app uploaded or serves from /_cdn/), by their full keys as run_code_in_vm's _floot.storageList returns them (\"public/…\" or \"private/…\"), up to 100 per call. The bytes are gone for good. For a public file of a published app, its CDN copy is removed too; the result says what to tell the user about that. Only when the user asked for the files to be deleted: to stop using a file, remove its reference from the code instead. Needs edit access to the project."
      },
      {
        "name": "call_app_function",
        "description": "Call one function of this project's own backend, the way its own code would: a function the project exports from helpers/flootAppExports.tsx, run in its published app, returning that function's JSON result. list_files shows the project's exported functions with their signatures; the function name and its input come from there. Use it to test an export after publishing it, or to do something for the user through the app's own logic instead of raw SQL. The function runs for real (a function that writes, sends or charges does so), so call one that changes anything only when the user asked for tha"
      },
      {
        "name": "navigate_preview",
        "description": "Point the user's OPEN Floot preview at what you built, to SHOW it to them; pair it with screenshot_preview to see it yourself. targetType \"page\": the app's router goes to `path`. \"component\": the component's .example.tsx for `name` (if it has none, say so or create one). \"page-examples\": the staged screens in pages/<name>.__example.tsx (the file must exist), listing them; \"#<screen>\" opens one. \"design\": the canvas designs/<name>.tsx fitted, listing its sections and frames; \"#<id>\" zooms to one. \"link-preview\": the link preview card (pages/<page>.ogImage.tsx) of the page at `path`, with its ve"
      },
      {
        "name": "screenshot_preview",
        "description": "Capture a screenshot of the user app. Call it whenever you want to SEE what the app currently looks like (layout, styling, rendered state) or want to debug the app. By default it shows whatever device the user has the preview on. Pass `viewport` to see it on another device — this is how to check a mobile or tablet layout: the preview switches to that device for the capture only, then back. Never build a separate \"mobile\" page or example just to look at a narrow layout."
      }
    ],
    "profiled_at": "2026-11-10T11:00:42.655Z"
  },
  "payment_method": "oauth"
}