ProductOS

Delete a file or directory from the project sandbox. Pass recursive:true to delete a non-empty directory. The project root cannot be deleted. Requires project:write scope.

delete_file

Deploy the active project to production: GitHub push → Vercel deployment (deterministic, no auto-fix). Runs asynchronously and shows live in the ProductOS UI. On a build failure it stops at FAILED with the build logs — read get_deploy_logs, fix the code (edit_file/bash), and call trigger_deploy again. Poll get_deploy_status for status/URL. Requires project:write scope.

trigger_deploy

Modify an existing file by replacing exact strings — the right tool for surgical code edits and refactors without rewriting the whole file. Edits apply in order; each oldString must appear exactly once unless replaceAll is set. Requires project:write scope.

edit_file

Find files by filename glob across the project sandbox (build artifacts pruned, capped at 500 results). Matches the file NAME, e.g. 'page.tsx', '*.config.*', 'tailwind.config.*'. To search file CONTENTS use search_files. Requires project:read scope.

find_files

Return the real failure logs for a mobile EAS build — the 'Run gradlew' (Android) / Xcode (iOS) phase output, plus the extracted cause. Use this whenever a Play Store / App Store build fails, ESPECIALLY when the status says "unknown error — see logs for the Run gradlew phase": that message is EAS's classifier giving up, and this tool fetches what it points at. Defaults to the project's most recent mobile build. Pass grep to filter (e.g. 'Execution failed|e: file://'). Requires project:read scope.

get_eas_build_logs

Returns a markdown summary of this ProductOS project: name, current stage, overview, PRD, research, design notes. Reads live wiki files from the project's sandbox — always the latest, no staleness. Call this first when the user wants you to work in their ProductOS project. v1 read-only.

get_project_context

Read the full body of one logged decision (PRD section, page) from this project's sandbox wiki. Pass an `id` from list_decisions (a wiki-relative path like 'agents/prd/sections/overview.md'). Returns markdown with title + stage + body. Live data — no DB lag.

get_decision

Return build AND runtime logs for a deployment. Build logs explain why a deploy failed to compile; runtime logs explain why a deployed route returns 500 (missing env var, Prisma init failure, DB unreachable). Falls back to fetching live from Vercel when nothing was captured at deploy time. Secrets and connection strings are redacted. Defaults to the latest deployment. Requires project:read scope.

get_deploy_logs

Orient in ProductOS Product mode — a Product groups several platform projects (web / mobile / website) that share ONE frozen spec, one database, and one orchestrator agent. Call this FIRST whenever the project you're working on might belong to a Product: it lists the sibling surfaces, whether the shared contract is frozen (and at which version), and what the ProductOS Agent is doing. With no arguments it resolves the Product owning the connection's active project, or — if that project is standalone — lists every Product this connection can reach. Follow up with read_shared_context (the contract each surface must satisfy) and product_agent (the main agent). Requires project:read.

get_product_context

Query a project's configuration in one call: name, stage, project type + framework template, GitHub repo/branch, workspace, database/storage provisioning state, and sandbox identity. Requires project:read scope.

get_project_metadata

Return the live preview URL for a project's running sandbox (and the Expo tunnel URL for mobile projects). Use to view or share the running app. If the sandbox isn't running, start it first with start_sandbox / open_project. Requires project:read scope.

get_sandbox_urls

Tail the dev-server log for a project's sandbox — use to debug build errors, runtime crashes, or a preview that won't load. Returns the last N lines (default 200) of the type-aware log file. Requires project:read scope.

get_sandbox_logs

Report a project's sandbox health: instance status (DEPLOYED/…), whether the dev server is responding, whether it's currently compiling, last-active time, and the sandbox id. Requires project:read scope.

get_sandbox_status

Git operations on the project sandbox. action='status' shows the working tree + recent commits (project:read). action='commit-push' commits the live sandbox state and pushes it to the project's GitHub repo via the durable commit pipeline — file writes via MCP already auto-commit, so use this to force an immediate sync point (project:write). action='pull' pulls the latest from the project's GitHub repo INTO the sandbox — it first backs up the current tree to S3 so the pull is undoable, and refuses while an agent turn is mid-write (project:write).

git_sync

Link a GitHub repository to this project so agents can understand the codebase. A Code Wiki (structured architecture docs) will be generated automatically. IMPORTANT: Always ask the user for confirmation before linking a repository.

add_context_repo

List the design / PRD / research decisions logged in this ProductOS project, read straight from the live sandbox wiki (no DB lag). Returns a JSON array with id (wiki-relative path), title, type, position, updatedAt for each. v1 returns PRD section files and pages; structured alternatives / rationale fields ship in v1.1.

list_decisions

List files and subdirectories in one directory of the project sandbox (non-recursive). Build artifacts (node_modules, .git, .next, dist, build) are hidden. For a full recursive tree use read_project_structure. Requires project:read scope.

list_files

List the ProductOS projects this MCP connection can access, with each project's access level (READ / WRITE / FULL_DEV), current stage, and id. Projects that are platforms of a multi-platform Product are grouped under it — use get_product_context for that Product's shared spec and orchestrator agent. The active project is marked — switch it with open_project, or pass projectId to any file/sandbox tool to target another project directly.

list_projects

List the user's GitHub repositories that can be linked for codebase context. Returns name, full_name, description, default_branch, and language for each repo. Use this to suggest which repos to link when the user describes an existing product.

list_available_repos

List the reusable agent skills (playbooks) available to this connection — platform skills shipped by ProductOS plus any this workspace or project defines. Each entry is a slug + description; call get_skill with a slug to read the full instructions. CHECK THIS FIRST when a task sounds like a repeatable workflow (cloning a website, an SEO pass, a design-system import) — following an existing skill beats improvising.

list_skills

List the ProductOS organizations (workspaces) this MCP connection can access, with your role in each. Use list_projects to see the projects inside them. Requires project:read scope.

list_organizations

Manage tabs in the shared browser session: list them, open a new one, switch by id/label (t1, t2, …), or close one. Requires project:exec scope.

browser_tabs

List, set, or delete a project's environment variables (the Secret Manager backing the sandbox's .env). 'list' returns key names only — values are encrypted and never exposed. 'set'/'delete' also sync the sandbox .env so the running app picks the change up. DATABASE_URL is reserved (use provision_database). Requires project:write scope.

manage_env_vars

Add, remove, or install npm dependencies in the project sandbox. 'add' installs the given packages, 'remove' uninstalls them, 'install' installs everything in package.json. Package names are validated. Requires project:exec scope.

manage_dependencies

Rename or move a file or directory within the project sandbox. Parent directories of the destination are created automatically. Requires project:write scope.

move_file

Navigate the project sandbox's Chromium to a URL. The app being built is at http://localhost:3000 — reachable ONLY from inside the sandbox, which is why this tool exists rather than fetching the URL yourself. Follow with browser_snapshot to see what is on the page. Shares one browser session with the in-app agents and the user's live Browser panel. Requires project:exec scope.

browser_navigate

Switch this MCP connection's active project and connect to its sandbox — auto-provisioning one (correct template image, state restored from GitHub/volume) when missing. Subsequent file/command tools default to this project. Returns sandbox status and preview URL. Requires project:read (sandbox creation needs project:write).

open_project

Read and drive the ProductOS Agent — the orchestrator that plans a Product, freezes its shared contract, and dispatches the per-surface builds. It is not a project and can't be reached with the project tools. Actions: 'status' (what it last said, whether it's mid-turn, and — crucially — whether it is parked awaiting plan approval, with the proposed plan); 'approve' (approve the parked plan so the builds start — this SPENDS CREDITS and dispatches real work across every surface, so confirm with the user first); 'answer' (reply to a parked question, or send plan feedback instead of approving — pass `message`); 'message' (send a new instruction to an idle agent — e.g. 'add a pricing page to web and mirror it on the website'). You share ONE session with the Product page's chat, so the user sees your messages live. 'status' needs project:read; the rest need project:write.

product_agent

Provision isolated file storage for the project (an S3 prefix with a project-scoped upload token) and write the PRODUCTOS_STORAGE_* credentials into the sandbox .env. Idempotent — safe to call again. The sandbox must be running. Requires project:write scope.

provision_storage

Provision a Postgres database for the project (Neon) and configure the sandbox: DATABASE_URL in .env, Prisma setup, and a db client. Idempotent — returns the existing database if already provisioned. The sandbox must be running. Requires project:write scope.

provision_database

Push the project's sandbox code to its GitHub repository. Dispatches an async job — check progress with get_deploy_status. Requires project:write scope.

push_to_github

Read the full instructions for one skill by slug (get slugs from list_skills). Returns the complete SKILL.md — a step-by-step playbook you should then FOLLOW for the current task, not summarise. Use this before improvising on any task a skill already covers.

get_skill

Read a file from the project's sandbox by path (relative to /home/user, e.g. 'src/app/page.tsx', or absolute). Text is returned inline (truncated at 200 KB); pass asBase64 for binary assets like images or fonts. Requires project:read scope.

read_file

Pull content out of the current page: visible text, innerHTML, an input's value, an attribute, the page title, or the current URL. Omit `target` for whole-page text. Use this rather than a screenshot when you need to READ something. Requires project:exec scope.

browser_read

Read the FROZEN shared contract every surface of a ProductOS Product is built against: spec/prd.md (requirements), spec/flows.md (user flows), spec/components.md (component spec), spec/design-tokens.json, spec/schema.prisma (the shared database), design-system/DESIGN.md, and progress/<surface>.md (what each sibling surface has done so far). Read the relevant parts BEFORE changing any surface of a Product — code that contradicts this contract will drift from the other platforms. Omit `path` to list what's available. This contract is READ-ONLY and has a single writer: never write into it (not via write_file into /home/user/shared either) — to change it, use manage_product({ action: "sync_spec" }). Requires project:read.

read_shared_context

Return the recursive file/directory tree of the project sandbox in one call (node_modules/.git/.next/dist/build pruned, capped at 2000 entries). Use this to understand project layout before reading specific files. Requires project:read scope.

read_project_structure

Restart a project's sandbox. Default (soft) restarts just the dev server process — fixes a wedged/stuck preview quickly. Pass hard:true to recreate the sandbox instance (persistent volume preserved) — use when the sandbox itself is broken; this returns immediately with a restart handle and runs in the background. Poll with action:'status' until it reports READY or FAILED. Requires project:exec scope.

restart_sandbox

Execute a bash command in the project's REMOTE cloud sandbox (working dir /home/user — the project root). This is NOT the local machine: all coding happens on the ProductOS sandbox, so you can drive a project from any device without a local clone. Full shell semantics: pipes, &&, globs, redirection, git, npm, tsc — anything installed in the sandbox. Synchronous commands time out at 55s: for anything longer (next build, a full test suite, prisma generate) pass background:true to get a jobId back immediately, then call again with that jobId to poll RUNNING/SUCCESS/FAILED/CANCELLED and read its output. File edits made via shell are auto-committed to GitHub like the file tools. Requires project:exec scope.

bash

Run the project's release checks against its live deployment and report each route's expected vs actual HTTP status. Uses the project's configured checks when it has them, otherwise derives them from the routes in the last deploy. Also re-checks that every built route exists in production and that the database is reachable. Use this to confirm whether a deployment is actually healthy, or to see exactly which routes are failing and with what status. Does not deploy or change anything.

run_release_checks

Save important facts, decisions, or context to long-term project memory. These persist across sessions and are searchable by in-app agents and via search_memory. Pass 1-4 facts per call. Requires project:write scope.

remember_fact