while.sh

Deploy and share tools built with Claude or ChatGPT: your team, a client or everyone. No sign-up.

Should I use this

Quality & Safety

A
Description quality
96%
Schema completeness
94%
Naming quality
92%
Poisoning risk
100%
Permission match
100%
Protocol compliance
100%

Findings (4)

  • LOWTool 'list_approvals' description lacks action verbin list_approvals
  • LOWTool 'get_project' description lacks action verbin get_project
  • LOWTool 'explain_access' description lacks action verbin explain_access
  • LOWTool 'request_access' description lacks action verbin request_access

Based on automated analysis of tool definitions and protocol compliance.

Context Cost

~12,739Tokens (tool definitions)
~2.6 KBTypical response size
Significant attention impact (9.95% of 128k context)

This is the approximate number of tokens consumed each time the server's tools are loaded into a model's context. Higher counts reduce the attention available for other tasks.

Install

One-Click Install

Add this to your `claude_desktop_config.json` file:

{
  "mcpServers": {
    "while": {
      "url": "https://app.while.sh/mcp"
    }
  }
}

Remote endpoints

https://app.while.sh/mcpstreamable-http
https://app.while.sh/mcp/connectorstreamable-http

What it can do

Tool inventory

Tools (44)

🟒 Read-only🟑 WriteπŸ”΄ Deleteβšͺ Unknown
🟒get_catalog(format, language, block, trial)

What while can run, block by block (a web app, a database, a bucket, a task, a connection…): what it does, its cost, the while.yaml line that declares it.

Input Schema

{
  "type": "object",
  "properties": {
    "format": {
      "type": "string",
      "enum": [
        "text",
        "detail",
        "json",
        "guide",
        "dockerfile"
      ],
      "default": "text",
      "description": "text: the contract and the blocks; detail: one block (block); guide: designing an app; dockerfile: a typical Dockerfile (language); json: the summary."
    },
    "language": {
      "type": "string",
      "enum": [
        "rails",
        "laravel",
        "rust",
        "java-maven",
        "java-gradle",
        "dotnet",
        "hugo"
      ],
      "description": "format dockerfile: the typical Dockerfile for this language; without it: the list."
    },
    "block": {
      "type": "string",
      "description": "format detail: a single building block, by its id (postgres, valkey…)."
    },
    "trial": {
      "type": "string",
      "description": "The key returned by the first deploy_app (trial_key), passed again on each call."
    }
  },
  "additionalProperties": false
}
🟒search_docs(query, lang, trial)

The passages of while's documentation that answer a question, with their address.

Input Schema

{
  "type": "object",
  "properties": {
    "query": {
      "type": "string",
      "description": "The question, in a few words."
    },
    "lang": {
      "type": "string",
      "enum": [
        "en",
        "fr"
      ],
      "description": "By default, the user's language."
    },
    "trial": {
      "type": "string",
      "description": "The key returned by the first deploy_app (trial_key), passed again on each call."
    }
  },
  "required": [
    "query"
  ],
  "additionalProperties": false
}
🟒read_source(project, environment, version, format, archive, ...)

The project's code at while, without changing anything: a folder (empty path or ending in /) gives its file list; a file, its content, in pages of 60,000 characters; archive: true, the archive link of a deployed version.

Input Schema

{
  "type": "object",
  "properties": {
    "project": {
      "type": "string",
      "description": "The project."
    },
    "environment": {
      "type": "string",
      "default": "production",
      "description": "archive: the version's environment (production by default)."
    },
    "version": {
      "type": "integer",
      "minimum": 1,
      "description": "archive: the version number; the live version by default."
    },
    "format": {
      "type": "string",
      "enum": [
        "auto",
        "base64",
        "link"
      ],
      "default": "auto",
      "description": "archive: the archive's form."
    },
    "archive": {
      "type": "boolean",
      "description": "true: the archive link of a deployed version."
    },
    "path": {
      "type": "string",
      "description": "A folder (empty, or ending in /): its list; a file: its content."
    },
    "start": {
      "type": "integer",
      "minimum": 1,
      "description": "A file: the first line returned (the rest of a long file, given by the response)."
    },
    "trial": {
      "type": "string",
      "description": "The key returned by the first deploy_app (trial_key), passed again on each call."
    }
  },
  "additionalProperties": false
}
🟑upload_source(project, environment, terminal, trial, language)

Trial version, not for production, online for a limited time. Without a key, this first call creates the trial. The upload command (curl) that sends the project folder to while from a terminal, through a one-hour link; deploy_app then deploys it.

Input Schema

{
  "type": "object",
  "properties": {
    "project": {
      "type": "string",
      "description": "The project."
    },
    "environment": {
      "type": "string",
      "default": "production",
      "description": "Production or a preview."
    },
    "terminal": {
      "type": "boolean",
      "description": "true: the curl command even when the client presents itself as a conversation (a client with a terminal that reaches while)."
    },
    "trial": {
      "type": "string",
      "description": "The key returned by the first deploy_app (trial_key), passed again on each call."
    },
    "language": {
      "type": "string",
      "enum": [
        "en",
        "fr"
      ],
      "description": "Trial creation: your user's language (while's for them, their app's and their emails'); without it, your session's, then English."
    }
  },
  "additionalProperties": false
}
πŸ”΄write_files(project, files, delete, message, trial, ...)

Trial version, not for production, online for a limited time. Without a key, this first call creates the trial. A commit on the project's branch at while, without a terminal: each named file is replaced by its full content, those in delete are removed; deploy_app then deploys this commit. 2 MiB and 200 files per call.

Input Schema

{
  "type": "object",
  "properties": {
    "project": {
      "type": "string",
      "description": "The project."
    },
    "files": {
      "type": "object",
      "additionalProperties": {
        "type": "string"
      },
      "description": "Path β†’ full text content of the file (it replaces the old one)."
    },
    "delete": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "maxItems": 200,
      "description": "The files or folders to delete."
    },
    "message": {
      "type": "string",
      "description": "The commit message, in one sentence."
    },
    "trial": {
      "type": "string",
      "description": "The key returned by the first deploy_app (trial_key), passed again on each call."
    },
    "language": {
      "type": "string",
      "enum": [
        "en",
        "fr"
      ],
      "description": "Trial creation: your user's language (while's for them, their app's and their emails'); without it, your session's, then English."
    }
  },
  "required": [
    "files"
  ],
  "additionalProperties": false
}
🟒plan_deploy(project, environment, plan_id, intent, from_state, ...)

What a deployment would change, block by block, and what each block costs per month, without changing anything; apply_plan applies it.

Input Schema

{
  "type": "object",
  "properties": {
    "project": {
      "type": "string",
      "description": "The project."
    },
    "environment": {
      "type": "string",
      "default": "production",
      "description": "Production or a preview."
    },
    "plan_id": {
      "type": "string",
      "description": "Reread this plan (computed earlier) instead of computing one."
    },
    "intent": {
      "type": "string",
      "description": "Content of while.yaml. Without this field, the last known file is used."
    },
    "from_state": {
      "type": "integer",
      "description": "Go back to a state version (number given by observe_app { view: \"history\" }): the plan says what to change to get it back; then apply_plan."
    },
    "timeout_seconds": {
      "type": "integer",
      "default": 120,
      "description": "Longest wait, in seconds."
    },
    "trial": {
      "type": "string",
      "description": "The key returned by the first deploy_app (trial_key), passed again on each call."
    }
  },
  "additionalProperties": false
}
πŸ”΄deploy_app(project, environment, source_archive_base64, release, redeploy, ...)

Trial version, not for production, online for a limited time. Without a key, this first call creates the trial. Builds the code sent (or a GitHub or GitLab repository linked with link_git_repo, an image) and deploys it to an environment, in place of the previous version; the response gives the version, its address, its build and what changed.

Input Schema

{
  "type": "object",
  "properties": {
    "project": {
      "type": "string",
      "description": "The project."
    },
    "environment": {
      "type": "string",
      "default": "production",
      "description": "Production or a preview."
    },
    "source_archive_base64": {
      "type": "string",
      "description": "Last resort, slow: the tar.gz archive of the sources, in base64. Exclusive with image and release."
    },
    "release": {
      "type": "integer",
      "description": "The number returned by an upload (or a version in progress): deploy_app follows its build and its deployment."
    },
    "redeploy": {
      "type": "integer",
      "description": "A version already built, put back online with today's variables and secrets (after set_env, or to restart an app that went down), without rebuilding. Going back: rollback_app."
    },
    "image": {
      "type": "string",
      "description": "OCI image already built (while registry or external), ideally with its digest."
    },
    "digest": {
      "type": "string",
      "description": "sha256:<64 hex>; without it, while resolves it: the image always goes by its digest."
    },
    "intent": {
      "type": "string",
      "description": "Content of while.yaml, when deploying an image without sending sources."
    },
    "confirm_overwrite": {
      "type": "boolean",
      "description": "true: while.yaml overwrites what a person changed on screen (after clarifying it with them)."
    },
    "wait": {
      "type": "boolean",
      "default": true,
      "description": "false: returns at once (follow with deploy_app { release })."
    },
    "timeout_seconds": {
      "type": "integer",
      "default": 300,
      "maximum": 1800,
      "description": "Maximum wait; beyond it, the response says how to resume."
    },
    "trial": {
      "type": "string",
      "description": "The key returned by the first deploy_app (trial_key), passed again on each call."
    },
    "language": {
      "type": "string",
      "enum": [
        "en",
        "fr"
      ],
      "description": "Trial creation: your user's language (while's for them, their app's and their emails'); without it, your session's, then English."
    }
  },
  "additionalProperties": false
}
🟒get_app_status(project, environment, include, since, probe, ...)

An environment's state: its live version, its addresses, its health, its services, its recent traffic; include: its live while.yaml file (while_yaml) or its known vulnerabilities and the bots seen (vulnerabilities).

Input Schema

{
  "type": "object",
  "properties": {
    "project": {
      "type": "string",
      "description": "The project."
    },
    "environment": {
      "type": "string",
      "default": "production",
      "description": "Production or a preview."
    },
    "include": {
      "type": "array",
      "items": {
        "type": "string",
        "enum": [
          "while_yaml",
          "vulnerabilities"
        ]
      },
      "maxItems": 1,
      "description": "An extra view on top of the state: while_yaml, or vulnerabilities."
    },
    "since": {
      "type": "string",
      "default": "24h",
      "description": "vulnerabilities: the window of bots seen in the traffic (30m, 6h, 1d…)."
    },
    "probe": {
      "type": "boolean",
      "default": true,
      "description": "false: without probing (does not wake a sleeping service)."
    },
    "trial": {
      "type": "string",
      "description": "The key returned by the first deploy_app (trial_key), passed again on each call."
    }
  },
  "additionalProperties": false
}
🟒list_approvals(id, trial)

The approvals a person still has to grant in while (a production deployment, a restore…), and their state; id: a single one.

Input Schema

{
  "type": "object",
  "properties": {
    "id": {
      "type": "string",
      "description": "Id of a request (approval_id): its detail, even decided."
    },
    "trial": {
      "type": "string",
      "description": "The key returned by the first deploy_app (trial_key), passed again on each call."
    }
  },
  "additionalProperties": false
}
🟒get_environment(view, project, environment, database, trial)

What is set on an environment, by view: variables, the names of its variables and secrets (never the values); domains, its domains and their DNS proof; links, its access links (never the link); backups, the last 50 backups of a database (the id for restore_backup); queues, its queues and their state.

Input Schema

{
  "type": "object",
  "properties": {
    "view": {
      "type": "string",
      "enum": [
        "variables",
        "domains",
        "links",
        "backups",
        "queues"
      ],
      "default": "variables",
      "description": "The view returned."
    },
    "project": {
      "type": "string",
      "description": "The project."
    },
    "environment": {
      "type": "string",
      "default": "production",
      "description": "Production or a preview."
    },
    "database": {
      "type": "string",
      "description": "Database name; the first declared by default."
    },
    "trial": {
      "type": "string",
      "description": "The key returned by the first deploy_app (trial_key), passed again on each call."
    }
  },
  "additionalProperties": false
}
πŸ”΄set_env(project, environment, values, secret, file, ...)

Sets or removes an environment's variables and secrets (in the vault by default, never read back); they apply at the next deployment. get_environment { view: "variables" } reads their names.

Input Schema

{
  "type": "object",
  "properties": {
    "project": {
      "type": "string",
      "description": "The project."
    },
    "environment": {
      "type": "string",
      "default": "production",
      "description": "Production or a preview."
    },
    "values": {
      "type": "object",
      "description": "Key/value pairs. Example: { \"LOG_LEVEL\": \"debug\" }",
      "additionalProperties": {
        "type": "string"
      }
    },
    "secret": {
      "type": "boolean",
      "default": true,
      "description": "true: in the vault, never read back (default). false: plain variable, readable on screen."
    },
    "file": {
      "type": "boolean",
      "default": false,
      "description": "true: a secret delivered as a file, never as a variable: the app reads it in /run/secrets/<NAME>. Required for a secret in the production of a project linked to a federated connection."
    },
    "build": {
      "type": "boolean",
      "default": false,
      "description": "true: a build secret (build.secrets, e.g. NPM_TOKEN), read by builds only, never by the app. With delete: removes one."
    },
    "delete": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "maxItems": 100,
      "description": "Names of the variables or secrets to delete from this environment."
    },
    "key": {
      "type": "string",
      "description": "A single variable: its name (with \"value\"), instead of \"values\"."
    },
    "value": {
      "type": "string",
      "description": "A single variable: its value (with \"key\")."
    },
    "move": {
      "type": "string",
      "description": "A name: this secret moves to the build (build: true) or to the app, its value kept in the vault."
    },
    "trial": {
      "type": "string",
      "description": "The key returned by the first deploy_app (trial_key), passed again on each call."
    }
  },
  "additionalProperties": false
}
🟒query_database(format, project, environment, database, sql, ...)

A read-only SQL query on one of the project's PostgreSQL databases; format short (default; a cut response says how to read the rest), detailed (wider limits) or csv (an export).

Input Schema

{
  "type": "object",
  "properties": {
    "format": {
      "type": "string",
      "enum": [
        "short",
        "detailed"
      ],
      "default": "short",
      "description": "The response format."
    },
    "project": {
      "type": "string",
      "description": "The project."
    },
    "environment": {
      "type": "string",
      "default": "production",
      "description": "Production or a preview."
    },
    "database": {
      "type": "string",
      "description": "Name of the database (databases[].name); the first declared by default."
    },
    "sql": {
      "type": "string",
      "description": "A read statement."
    },
    "limit": {
      "type": "integer",
      "minimum": 1,
      "maximum": 50000,
      "description": "Row cap: short 200, detailed 400 (2,000 at most); csv 10,000 (50,000)."
    },
    "max_bytes": {
      "type": "integer",
      "minimum": 1000,
      "maximum": 200000,
      "description": "Byte limit: short 40 KB, detailed and csv 200 KB."
    },
    "timeout_seconds": {
      "type": "number",
      "default": 10,
      "minimum": 0.5,
      "maximum": 30,
      "description": "Query timeout."
    },
    "trial": {
      "type": "string",
      "description": "The key returned by the first deploy_app (trial_key), passed again on each call."
    }
  },
  "required": [
    "sql"
  ],
  "additionalProperties": false
}
🟒get_logs(project, environment, build_id, query, limit, ...)

An environment's logs (or a build's: build_id), most recent first, filterable by a text.

Input Schema

{
  "type": "object",
  "properties": {
    "project": {
      "type": "string",
      "description": "The project."
    },
    "environment": {
      "type": "string",
      "default": "production",
      "description": "Production or a preview."
    },
    "build_id": {
      "type": "string",
      "description": "To read a build's log rather than the application's."
    },
    "query": {
      "type": "string",
      "description": "A LogsQL filter (VictoriaLogs' query language: https://docs.victoriametrics.com/victorialogs/logsql/), for example \"timeout\"; \"error\": the error lines."
    },
    "limit": {
      "type": "integer",
      "maximum": 1000,
      "description": "Lines returned: 100 by default, 200 with build_id; 1,000 at most."
    },
    "trial": {
      "type": "string",
      "description": "The key returned by the first deploy_app (trial_key), passed again on each call."
    }
  },
  "additionalProperties": false
}
🟒observe_app(view, project, environment, query, range, ...)

What is happening in production, by view: metrics, traces, errors (grouped), history (versions and events), timeline, impact (a version's effect), database (the most frequent and slowest SQL queries) or ask (dated facts around a question).

Input Schema

{
  "type": "object",
  "properties": {
    "view": {
      "type": "string",
      "enum": [
        "metrics",
        "traces",
        "errors",
        "history",
        "timeline",
        "impact",
        "database",
        "ask"
      ],
      "default": "metrics",
      "description": "The view returned."
    },
    "project": {
      "type": "string",
      "description": "The project."
    },
    "environment": {
      "type": "string",
      "default": "production",
      "description": "Production or a preview."
    },
    "query": {
      "type": "string",
      "description": "A PromQL query (Prometheus' query language: https://prometheus.io/docs/prometheus/latest/querying/basics/); without it, traffic and errors."
    },
    "range": {
      "type": "string",
      "enum": [
        "15m",
        "1h",
        "24h",
        "7d"
      ],
      "default": "1h",
      "description": "The window."
    },
    "trace_id": {
      "type": "string",
      "description": "One trace in detail: its id (32 hexadecimal characters)."
    },
    "service": {
      "type": "string",
      "description": "The app's OTEL_SERVICE_NAME; by default, the project's name (what while sets)."
    },
    "operation": {
      "type": "string",
      "description": "Only the traces of this operation (span name), for example \"GET /orders\"."
    },
    "since_minutes": {
      "type": "integer",
      "default": 60,
      "description": "Window, in minutes (30 days at most)."
    },
    "min_duration": {
      "type": "string",
      "description": "Only the traces longer than this, for example \"500ms\" or \"2s\"."
    },
    "errors": {
      "type": "boolean",
      "default": false,
      "description": "Only the traces with a span in error."
    },
    "limit": {
      "type": "integer",
      "default": 20,
      "description": "100 at most."
    },
    "since": {
      "type": "string",
      "default": "24h",
      "description": "Window: 30m, 2h, 1d, or an ISO 8601 date."
    },
    "fingerprint": {
      "type": "string",
      "description": "Fingerprint of a group, for its detail."
    },
    "until": {
      "type": "string",
      "description": "End (ISO 8601 date); now by default."
    },
    "families": {
      "type": "array",
      "items": {
        "type": "string",
        "enum": [
          "build",
          "plan",
          "deploy",
          "rollback",
          "incident",
          "error",
          "preview",
          "approval",
          "sleep",
          "data",
          "task",
          "security",
          "cost",
          "agent",
          "other"
        ]
      },
      "description": "Keep only these families."
    },
    "version": {
      "type": "integer",
      "description": "Version number; the active version by default."
    },
    "window_minutes": {
      "type": "integer",
      "default": 30,
      "minimum": 5,
      "maximum": 1440,
      "description": "The compared window, before and after the version."
    },
    "database": {
      "type": "string",
      "description": "Database name; the first declared by default."
    },
    "question": {
      "type": "string",
      "minLength": 3,
      "description": "The question, in plain words."
    },
    "trial": {
      "type": "string",
      "description": "The key returned by the first deploy_app (trial_key), passed again on each call."
    }
  },
  "additionalProperties": false
}
🟑send_feedback(kind, message, project, organization, tool, ...)

Sends feedback to the while team (a bug, a gap, an idea) in the person's words, when they ask for it. while attaches who sends it, the organization, while's version and the last 5 failed calls of this identity (the tool and the code only); nothing else from the conversation is sent.

Input Schema

{
  "type": "object",
  "properties": {
    "kind": {
      "type": "string",
      "enum": [
        "bug",
        "frustration",
        "idea",
        "other",
        "integration",
        "block"
      ],
      "description": "bug (while is wrong), frustration (the user's, in their words), idea, other, integration (a service to connect), block (a block to open)."
    },
    "message": {
      "type": "string",
      "maxLength": 4000,
      "description": "What happens, what was expected; 4,000 characters at most."
    },
    "project": {
      "type": "string",
      "description": "The project concerned."
    },
    "organization": {
      "type": "string",
      "description": "The organization; otherwise the project's or the token's."
    },
    "tool": {
      "type": "string",
      "description": "The MCP tool concerned."
    },
    "route": {
      "type": "string",
      "description": "The API route concerned (\"POST /v1/…\")."
    },
    "reference": {
      "type": "string",
      "description": "The identifier of an error, a call or an approval."
    },
    "service": {
      "type": "string",
      "maxLength": 100,
      "description": "integration: the service to connect (Stripe, Snowflake, Anthropic…)."
    },
    "usage": {
      "type": "string",
      "maxLength": 1000,
      "description": "integration, block: what the app wants to do with it."
    },
    "block": {
      "type": "string",
      "maxLength": 60,
      "description": "block: the block (its id in catalog)."
    },
    "volume": {
      "type": "string",
      "maxLength": 200,
      "description": "block: the expected volume (sends per day, GiB…)."
    },
    "authentication": {
      "type": "string",
      "enum": [
        "api_key",
        "oauth",
        "oidc_federation",
        "other"
      ],
      "description": "integration: how the service authenticates, if you know (API key, OAuth, OIDC federation, other)."
    },
    "documentation": {
      "type": "string",
      "maxLength": 500,
      "pattern": "^https://",
      "description": "integration: the https address of its documentation."
    },
    "trial": {
      "type": "string",
      "description": "The key returned by the first deploy_app (trial_key), passed again on each call."
    }
  },
  "required": [
    "kind",
    "message"
  ],
  "additionalProperties": false
}
🟒list_feedback(organization, trial)

The feedback sent to the while team and its replies; organization: the organization's feedback (its admins).

Input Schema

{
  "type": "object",
  "properties": {
    "organization": {
      "type": "string",
      "description": "The whole organization's feedback (its admins)."
    },
    "trial": {
      "type": "string",
      "description": "The key returned by the first deploy_app (trial_key), passed again on each call."
    }
  },
  "additionalProperties": false
}
🟒get_project(project, include, trial)

Without project, the projects the identity sees; project, one project and its environments; include: ["webhooks"], its webhooks.

Input Schema

{
  "type": "object",
  "properties": {
    "project": {
      "type": "string",
      "description": "A project; without it, the list."
    },
    "include": {
      "type": "array",
      "items": {
        "type": "string",
        "enum": [
          "webhooks"
        ]
      },
      "maxItems": 1,
      "description": "webhooks: its webhooks."
    },
    "trial": {
      "type": "string",
      "description": "The key returned by the first deploy_app (trial_key), passed again on each call."
    }
  },
  "additionalProperties": false
}
🟑create_project(project, name, budget_eur, organization, trial)

Creates a project in an organization, with its monthly budget (€20 by default); deploy_app then deploys an app to it.

Input Schema

{
  "type": "object",
  "properties": {
    "project": {
      "type": "string",
      "description": "The project name (lowercase letters, digits, hyphens)."
    },
    "name": {
      "type": "string",
      "description": "The display name (the project name by default)."
    },
    "budget_eur": {
      "type": "number",
      "minimum": 0,
      "description": "Euros per month (20 by default; 0, no cap, or more than €20: admins); alert at 80% then 100%."
    },
    "organization": {
      "type": "string",
      "description": "The organization that holds it (the token's by default)."
    },
    "trial": {
      "type": "string",
      "description": "The key returned by the first deploy_app (trial_key), passed again on each call."
    }
  },
  "required": [
    "project"
  ],
  "additionalProperties": false
}
🟑keep_trial(organization_name, project_name, trial)

When the user wants to keep their trial app: returns the link that keeps it in their own organization. Ask them first for their organization's name, and for the project's name, which makes the app's address; the page proposes names and lets them change them.

Input Schema

{
  "type": "object",
  "properties": {
    "organization_name": {
      "type": "string",
      "maxLength": 60,
      "description": "The user's organization."
    },
    "project_name": {
      "type": "string",
      "maxLength": 40,
      "description": "The project, which makes the app's address."
    },
    "trial": {
      "type": "string",
      "description": "The key returned by the first deploy_app (trial_key), passed again on each call."
    }
  }
}
βšͺsign_up(email, trial)

Sends the user's email address to while, which emails them a link (60 min) to choose a password. With the trial key, the trial app moves to their account. The link and the password are never returned here.

Input Schema

{
  "type": "object",
  "properties": {
    "email": {
      "type": "string",
      "description": "The user's email address."
    },
    "trial": {
      "type": "string",
      "description": "The key returned by the first deploy_app (trial_key), passed again on each call."
    }
  },
  "required": [
    "email"
  ]
}
βšͺload_tools(group)

Adds a tool group to this agent: alerts (alerts, incidents, channels), feedback_and_docs (page notes, feedback, docs), environments_and_storage (domains, internal apps, git credential, buckets, destroying or restarting an environment), administer (members, groups, roles, access, tokens, service accounts, bindings, usage, project settings and deletion, organization settings).

Input Schema

{
  "type": "object",
  "properties": {
    "group": {
      "type": "string",
      "enum": [
        "alerts",
        "feedback_and_docs",
        "environments_and_storage",
        "administer"
      ],
      "description": "The group to load."
    }
  },
  "required": [
    "group"
  ],
  "additionalProperties": false
}
πŸ”΄link_git_repo(project, forge, repo, token, base_url, ...)

Keeps the code on GitHub or GitLab: a push to the default branch deploys production, a pull or merge request opens a preview; unlink removes the link.

Input Schema

{
  "type": "object",
  "properties": {
    "project": {
      "type": "string",
      "description": "The project."
    },
    "forge": {
      "type": "string",
      "enum": [
        "github",
        "gitlab"
      ],
      "description": "The repository's forge."
    },
    "repo": {
      "type": "string",
      "description": "\"owner/name\" (GitHub) or \"group/project\" (GitLab)."
    },
    "token": {
      "type": "string",
      "description": "Access token for the forge; it goes to the vault."
    },
    "base_url": {
      "type": "string",
      "description": "Address of a self-hosted GitLab."
    },
    "unlink": {
      "type": "boolean",
      "default": false,
      "description": "true: removes the link and the webhook."
    }
  },
  "additionalProperties": false
}
πŸ”΄apply_plan(plan_id, project, wait, timeout_seconds, discard)

Applies a plan computed by plan_deploy (what it changes goes live); discard: true drops it without applying anything.

Input Schema

{
  "type": "object",
  "properties": {
    "plan_id": {
      "type": "string",
      "description": "The plan returned by plan_deploy."
    },
    "project": {
      "type": "string",
      "description": "The project."
    },
    "wait": {
      "type": "boolean",
      "default": true,
      "description": "true: answers once done."
    },
    "timeout_seconds": {
      "type": "integer",
      "default": 300,
      "description": "Longest wait, in seconds."
    },
    "discard": {
      "type": "boolean",
      "default": false,
      "description": "true: drop the plan instead of applying it."
    }
  },
  "required": [
    "plan_id"
  ],
  "additionalProperties": false
}
πŸ”΄rollback_app(project, environment, to, wait, approval_id)

Puts a previous version of an environment back online (the previous one by default, or to); the live version is replaced.

Input Schema

{
  "type": "object",
  "properties": {
    "project": {
      "type": "string",
      "description": "The project."
    },
    "environment": {
      "type": "string",
      "default": "production",
      "description": "Production or a preview."
    },
    "to": {
      "type": "integer",
      "description": "The target version number; without it, the previous active version."
    },
    "wait": {
      "type": "boolean",
      "default": true,
      "description": "true: answers once done."
    },
    "approval_id": {
      "type": "string",
      "description": "Approval granted, when the organization requires an approval for a rollback in production."
    }
  },
  "additionalProperties": false
}
πŸ”΄create_preview(project, name, branch, from, copy_database, ...)

A preview environment for a branch, with its own address and, on request, a copy of the production database.

Input Schema

{
  "type": "object",
  "properties": {
    "project": {
      "type": "string",
      "description": "The project."
    },
    "name": {
      "type": "string",
      "description": "Name of the environment (otherwise, the branch)."
    },
    "branch": {
      "type": "string",
      "description": "The Git branch."
    },
    "from": {
      "type": "string",
      "default": "production",
      "description": "Reference environment."
    },
    "copy_database": {
      "type": "boolean",
      "default": false,
      "description": "Copy the production data (otherwise empty databases): needs data.backup on its databases."
    },
    "ttl_hours": {
      "type": "integer",
      "default": 24,
      "description": "Lifetime of the preview, in hours."
    },
    "wait": {
      "type": "boolean",
      "default": true,
      "description": "true: answers once done."
    }
  },
  "additionalProperties": false
}
🟒request_access_link(project, environment, name, days, dev_address)

Share an internal app, show it to a client or a tester without a while account: requests a sharing link (access link); a person creates it and passes it on in while. With dev_address: the workstation's dev address (its dev server), 7 days at most.

Input Schema

{
  "type": "object",
  "properties": {
    "project": {
      "type": "string",
      "description": "The project."
    },
    "environment": {
      "type": "string",
      "default": "production",
      "description": "Production or a preview."
    },
    "name": {
      "type": "string",
      "description": "The proposed name of the link (\"Dupont client demo\")."
    },
    "days": {
      "type": "integer",
      "description": "The proposed expiry: 1, 7 or 30 days (otherwise 7)."
    },
    "dev_address": {
      "type": "string",
      "description": "The name of a dev address (what follows -dev- in <project>-dev-<name>): share it rather than an environment."
    }
  },
  "additionalProperties": false
}
βšͺbackup_database(project, environment, database, test_restore, wait)

Starts a backup of a database declared in while.yaml, and a test restore on a throwaway database that proves it.

Input Schema

{
  "type": "object",
  "properties": {
    "project": {
      "type": "string",
      "description": "The project."
    },
    "environment": {
      "type": "string",
      "default": "production",
      "description": "Production or a preview."
    },
    "database": {
      "type": "string",
      "description": "Database name; the first declared by default."
    },
    "test_restore": {
      "type": "boolean",
      "default": true,
      "description": "Restore it to a throwaway database, to prove it."
    },
    "wait": {
      "type": "boolean",
      "default": false,
      "description": "Wait for the backup (and its restore test) to receive its id and its result."
    }
  },
  "additionalProperties": false
}
πŸ”΄restore_backup(project, environment, database, backup_id, instant, ...)

Restores a database from a backup (the last successful one by default) or to a point in time; its current data is replaced, with an approval in production.

Input Schema

{
  "type": "object",
  "properties": {
    "project": {
      "type": "string",
      "description": "The project."
    },
    "environment": {
      "type": "string",
      "default": "production",
      "description": "Production or a preview."
    },
    "database": {
      "type": "string",
      "description": "Database name; the first declared by default."
    },
    "backup_id": {
      "type": "string",
      "description": "The backup (get_environment { view: \"backups\" }); the last successful one by default."
    },
    "instant": {
      "type": "string",
      "description": "Restore the database to this instant (ISO 8601), 14 days at most; excludes backup_id."
    },
    "approval_id": {
      "type": "string",
      "description": "The granted approval (its id), when the action needs one."
    },
    "wait": {
      "type": "boolean",
      "default": false,
      "description": "true: answers once done."
    },
    "reason": {
      "type": "string",
      "description": "Why restore, in one sentence for the person who approves."
    }
  },
  "additionalProperties": false
}
🟒list_tasks(project, environment, task, limit)

An environment's scheduled jobs, their schedule, their last runs and the next one.

Input Schema

{
  "type": "object",
  "properties": {
    "project": {
      "type": "string",
      "description": "The project."
    },
    "environment": {
      "type": "string",
      "default": "production",
      "description": "Production or a preview."
    },
    "task": {
      "type": "string",
      "description": "Name of a task, for its detailed history."
    },
    "limit": {
      "type": "integer",
      "default": 20,
      "maximum": 200,
      "description": "Number of runs in the detailed history."
    }
  },
  "additionalProperties": false
}
πŸ”΄run_task(project, environment, task, args, env, ...)

Runs a task declared in while.yaml now, outside its schedule; it does what its code does.

Input Schema

{
  "type": "object",
  "properties": {
    "project": {
      "type": "string",
      "description": "The project."
    },
    "environment": {
      "type": "string",
      "default": "production",
      "description": "Production or a preview."
    },
    "task": {
      "type": "string",
      "description": "Name of the task (crons[].name)."
    },
    "args": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "maxItems": 20,
      "description": "Arguments appended to the command, for example [\"--since\", \"2026-10-12\"]."
    },
    "env": {
      "type": "object",
      "additionalProperties": {
        "type": "string"
      },
      "description": "Extra variables for this run only."
    },
    "catch_up": {
      "type": "object",
      "additionalProperties": false,
      "required": [
        "start"
      ],
      "properties": {
        "start": {
          "type": "string",
          "description": "Start of the period: 2026-10-12, or an ISO 8601 instant."
        },
        "end": {
          "type": "string",
          "description": "End of the period (included); the start by default."
        }
      },
      "description": "Period to catch up: the run is counted \"catch_up\" and receives it as variables."
    },
    "wait": {
      "type": "boolean",
      "default": false,
      "description": "true: answers once done."
    },
    "timeout_seconds": {
      "type": "integer",
      "default": 300,
      "maximum": 1800,
      "description": "Longest wait, in seconds."
    },
    "approval_id": {
      "type": "string",
      "description": "Approval granted, when the organization requires an approval for tasks in production."
    }
  },
  "required": [
    "task"
  ],
  "additionalProperties": false
}
βšͺacknowledge_announcement(id)

Records that an announcement from the while team has been read.

Input Schema

{
  "type": "object",
  "properties": {
    "id": {
      "type": "string",
      "description": "The id of the announcement (id, in the announcements)."
    }
  },
  "required": [
    "id"
  ],
  "additionalProperties": false
}
🟒explain_access(organization, project, scope, who, permission, ...)

Who has access to what, in sentences; with who and permission, yes or no and why (the chain that grants it, or what is missing); activity: what this identity did with it.

Input Schema

{
  "type": "object",
  "properties": {
    "organization": {
      "type": "string",
      "description": "The organization."
    },
    "project": {
      "type": "string",
      "description": "Shortcut for scope.project."
    },
    "scope": {
      "type": "object",
      "additionalProperties": false,
      "description": "{}: the organization; otherwise down to a table, or a connection.",
      "properties": {
        "type": {
          "type": "string",
          "enum": [
            "organization"
          ],
          "description": "The whole organization."
        },
        "project": {
          "type": "string",
          "description": "Project name."
        },
        "environment": {
          "type": "string",
          "description": "The environment."
        },
        "database": {
          "type": "string",
          "description": "Database name."
        },
        "schema": {
          "type": "string",
          "description": "PostgreSQL schema."
        },
        "table": {
          "type": "string",
          "description": "\"schema.table\"."
        },
        "columns": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "maxItems": 1600,
          "description": "The table's columns."
        },
        "connection": {
          "type": "string",
          "description": "Connection name."
        },
        "paths": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "maxItems": 100,
          "description": "Patterns, e.g. \"/notes/**\"."
        }
      }
    },
    "who": {
      "type": "string",
      "description": "An address, group:<name>, service_account:<name>, app:<project>/<service>, task:<project>/<task>, or token:<id or name>."
    },
    "permission": {
      "type": "string",
      "enum": [
        "org.view",
        "org.admin",
        "access.grant",
        "roles.define",
        "projects.create",
        "app.use",
        "project.view",
        "project.deploy",
        "project.configure",
        "tasks.run",
        "project.destroy",
        "data.read",
        "data.write",
        "data.schema",
        "data.backup",
        "connection.read",
        "connection.write",
        "connection.configure",
        "log.read",
        "log.export"
      ],
      "description": "With who: \"can X <permission> on the scope?\"."
    },
    "activity": {
      "type": "boolean",
      "default": true,
      "description": "With who: what the identity did (log, calls)."
    }
  },
  "additionalProperties": false
}
βšͺrequest_access(organization, role, permission, scope, days, ...)

Requests a permission for the person (or their agent): whoever can grant it decides in while.

Input Schema

{
  "type": "object",
  "properties": {
    "organization": {
      "type": "string",
      "description": "The organization."
    },
    "role": {
      "type": "string",
      "description": "The role (missing.proposed_role)."
    },
    "permission": {
      "type": "string",
      "enum": [
        "org.view",
        "org.admin",
        "access.grant",
        "roles.define",
        "projects.create",
        "app.use",
        "project.view",
        "project.deploy",
        "project.configure",
        "tasks.run",
        "project.destroy",
        "data.read",
        "data.write",
        "data.schema",
        "data.backup",
        "connection.read",
        "connection.write",
        "connection.configure",
        "log.read",
        "log.export"
      ],
      "description": "Or a permission (the smallest role that grants it)."
    },
    "scope": {
      "type": "object",
      "additionalProperties": false,
      "description": "{}: the organization; otherwise down to a table, or a connection.",
      "properties": {
        "type": {
          "type": "string",
          "enum": [
            "organization"
          ],
          "description": "The whole organization."
        },
        "project": {
          "type": "string",
          "description": "Project name."
        },
        "environment": {
          "type": "string",
          "description": "The environment."
        },
        "database": {
          "type": "string",
          "description": "Database name."
        },
        "schema": {
          "type": "string",
          "description": "PostgreSQL schema."
        },
        "table": {
          "type": "string",
          "description": "\"schema.table\"."
        },
        "columns": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "maxItems": 1600,
          "description": "The table's columns."
        },
        "connection": {
          "type": "string",
          "description": "Connection name."
        },
        "paths": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "maxItems": 100,
          "description": "Patterns, e.g. \"/notes/**\"."
        }
      }
    },
    "days": {
      "type": "integer",
      "minimum": 1,
      "maximum": 90,
      "default": 7,
      "description": "Duration, in days."
    },
    "reason": {
      "type": "string",
      "description": "Why (\"Q4 audit\"), read by whoever decides."
    },
    "renew": {
      "type": "string",
      "description": "One of your assignments to extend (only days and reason count)."
    },
    "for": {
      "type": "string",
      "description": "For an app that will call a connection: app:<project>/<service> or task:<project>/<task>, role connection-caller (or connection-writer), scope { connection }."
    },
    "tool": {
      "type": "string",
      "description": "Or the id of a reserved tool (view existing)."
    }
  },
  "required": [
    "reason"
  ],
  "additionalProperties": false
}
🟒get_activity_log(organization, tab, person, via, family, ...)

The organization's activity log, append-only and chained: who did what and through what (a person, an agent, the API, a task, while), filterable.

Input Schema

{
  "type": "object",
  "properties": {
    "organization": {
      "type": "string",
      "description": "The organization."
    },
    "tab": {
      "type": "string",
      "enum": [
        "all",
        "agents",
        "security",
        "approvals"
      ],
      "default": "all",
      "description": "Ready-made filter."
    },
    "person": {
      "type": "string",
      "description": "Address or name (partial) of the person, or \"while\"."
    },
    "via": {
      "type": "string",
      "enum": [
        "agent",
        "app",
        "task",
        "interface",
        "browser",
        "api",
        "while"
      ],
      "description": "What the action went through."
    },
    "family": {
      "type": "string",
      "description": "Families, separated by commas: deploy, data, security, access, permissions, approval, task, alert, connection, app, observation, loop (agents' wake-ups)."
    },
    "project": {
      "type": "string",
      "description": "Project name."
    },
    "resource": {
      "type": "string",
      "description": "Text searched in the object (\"carnet\", \"main.reservations\"), or id or type of resource."
    },
    "who": {
      "type": "string",
      "description": "An identity written as for explain_access: an address, service_account:<name>, app:<project>/<service> (what it did)."
    },
    "assignment": {
      "type": "string",
      "description": "An assignment's history (its id): granted, revoked, expired, flagged, kept."
    },
    "since": {
      "type": "string",
      "description": "Start: 30m, 24h, 7d, a date (2026-10-18) or an ISO 8601 instant."
    },
    "until": {
      "type": "string",
      "description": "End, same format; a date alone counts the whole day."
    },
    "limit": {
      "type": "integer",
      "default": 50,
      "minimum": 1,
      "maximum": 200,
      "description": "Maximum number of items returned."
    },
    "cursor": {
      "type": "string",
      "description": "The \"next\" of a previous response."
    },
    "verify": {
      "type": "boolean",
      "default": false,
      "description": "Check the log's chain instead of reading it."
    }
  },
  "additionalProperties": false
}
🟒list_connections(view, organization, connection, since, until, ...)

The organization's external APIs, called through while: without connection, their list; connection, its detail, its rules and how to call it; view limits, the call limits; bindings, a federated connection's bindings.

Input Schema

{
  "type": "object",
  "properties": {
    "view": {
      "type": "string",
      "enum": [
        "detail",
        "limits",
        "bindings"
      ],
      "default": "detail",
      "description": "The view returned."
    },
    "organization": {
      "type": "string",
      "description": "The organization."
    },
    "connection": {
      "type": "string",
      "description": "Connection name (meteo): its detail."
    },
    "since": {
      "type": "string",
      "description": "With connection: the call log since this date (2026-10-01); 7 days by default."
    },
    "until": {
      "type": "string",
      "description": "With connection and since: up to this date (now by default)."
    },
    "refusal": {
      "type": "boolean",
      "description": "With since: refusals only."
    }
  },
  "additionalProperties": false
}
πŸ”΄declare_connection(organization, name, model, domain, secondary_domains, ...)

Declares an external API (domain, authentication without a secret, callers), to be approved; a person enters the secret in while.

Input Schema

{
  "type": "object",
  "properties": {
    "organization": {
      "type": "string",
      "description": "The organization."
    },
    "name": {
      "type": "string",
      "description": "Lowercase, digits, hyphens: weather, accounting."
    },
    "model": {
      "type": "string",
      "enum": [
        "anthropic",
        "openai",
        "mistral",
        "snowflake",
        "snowflake_pat"
      ],
      "description": "An AI or Snowflake (account, user, role, warehouse): domain and recipe set automatically."
    },
    "domain": {
      "type": "string",
      "description": "API host name, no path: api.example.com."
    },
    "secondary_domains": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "maxItems": 10,
      "description": "Hosts relayed without a key (/~<host>/…)."
    },
    "authentication": {
      "type": "object",
      "description": "Recipe, no secret: none; header {name, prefix}; parameter {name}; basic; bearer; oauth2 {token_url|issuer, scope, client_auth basic|body, header}; session {login_url, token_field, duration_seconds}; jwt {mode exchange|client_assertion|direct, token_url|issuer, alg RS256|ES256, duration_s, claims {iss, aud, scope, sub}, client_id, scope}, signed by while; model google {client_email, scopes}, salesforce {client_id, sub}, microsoft {tenant_id, client_id, scope, x5t}; federated: google {project_number, pool, provider, scopes, service_account?}, azure {tenant, client_id, scope}, generic {exchange_url}.",
      "properties": {
        "type": {
          "type": "string",
          "enum": [
            "none",
            "header",
            "parameter",
            "basic",
            "bearer",
            "oauth2",
            "session",
            "jwt",
            "federated"
          ],
          "description": "The recipe's kind."
        },
        "model": {
          "type": "string",
          "enum": [
            "google",
            "salesforce",
            "microsoft",
            "azure",
            "generic"
          ],
          "description": "The provider, for model or federated."
        }
      }
    },
    "rules": {
      "type": "array",
      "maxItems": 100,
      "description": "Federated: required; a POST that reads: its pattern also in post_read.",
      "items": {
        "type": "object",
        "properties": {
          "method": {
            "type": "string",
            "description": "HTTP method."
          },
          "pattern": {
            "type": "string",
            "description": "Path, e.g. /api/v1/slots/*/close."
          },
          "read": {
            "type": "boolean",
            "description": "A POST that only reads."
          },
          "approve_each_call": {
            "type": "boolean",
            "description": "true: each call waits for an approval."
          }
        },
        "required": [
          "method",
          "pattern"
        ],
        "additionalProperties": false
      }
    },
    "post_read": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Patterns read with POST, allowed during learning: /api/v1/searches."
    },
    "learning_days": {
      "type": "integer",
      "default": 7,
      "minimum": 1,
      "maximum": 30,
      "description": "Days of learning."
    },
    "rate_per_minute": {
      "type": "integer",
      "default": 600,
      "minimum": 1,
      "maximum": 60000,
      "description": "Calls allowed per minute."
    },
    "owner": {
      "type": "string",
      "description": "Email of the owner; by default, the signed-in user."
    },
    "label": {
      "type": "string",
      "description": "The displayed name (\"Pennylane\")."
    },
    "project": {
      "type": "string",
      "description": "The project of the calling apps; by default, the token's."
    },
    "apps": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "maxItems": 20,
      "description": "Calling services and tasks (web, task:charger); by default, those of the while.yaml that declare it."
    },
    "direction": {
      "type": "string",
      "enum": [
        "read",
        "write"
      ],
      "default": "read",
      "description": "The apps will also write (POST, PUT, PATCH, DELETE)."
    },
    "update": {
      "type": "boolean",
      "description": "An existing connection: post_read becomes the wanted list; removing applies at once, adding goes through approval."
    }
  },
  "required": [
    "name"
  ],
  "additionalProperties": false
}
πŸ”΄call_connection(organization, connection, method, path, body, ...)

Calls the HTTP API of a third party that the organization declared as a connection (its name and domain: list_connections), on its base address, within its rules and limits; while adds the authentication and keeps a record of the call.

Input Schema

{
  "type": "object",
  "properties": {
    "organization": {
      "type": "string",
      "description": "The organization."
    },
    "connection": {
      "type": "string",
      "description": "Connection name (list_connections)."
    },
    "method": {
      "type": "string",
      "enum": [
        "GET",
        "HEAD",
        "POST",
        "PUT",
        "PATCH",
        "DELETE",
        "OPTIONS"
      ],
      "default": "GET",
      "description": "HTTP method."
    },
    "path": {
      "type": "string",
      "description": "Path at the provider, with its query string: /api/v1/slots?site=origines."
    },
    "body": {
      "description": "Request body: an object (sent as JSON) or text."
    },
    "type": {
      "type": "string",
      "description": "Type of the body (Content-Type), if it is not JSON."
    },
    "call": {
      "type": "string",
      "description": "Id of a held call: its state and, once run, its result."
    }
  },
  "required": [
    "connection"
  ],
  "additionalProperties": false
}
🟒get_organization(view, organization)

Without organization, your organizations; otherwise, view detail (members, groups, approvers), existing (what exists for the person, to_say), map (projects, databases, connections), rules (approvals, budget), branding.

Input Schema

{
  "type": "object",
  "properties": {
    "view": {
      "type": "string",
      "enum": [
        "detail",
        "existing",
        "map",
        "rules",
        "branding"
      ],
      "default": "detail",
      "description": "The view returned."
    },
    "organization": {
      "type": "string",
      "description": "The organization."
    }
  },
  "additionalProperties": false
}
βšͺinvite_member(organization, email, role, project, reason, ...)

Invites a person with a role on an app (project; otherwise the whole organization); resend: true sends their pending invitation again (a new link, once an hour).

Input Schema

{
  "type": "object",
  "properties": {
    "organization": {
      "type": "string",
      "description": "The organization."
    },
    "email": {
      "type": "string",
      "description": "The person's address."
    },
    "role": {
      "type": "string",
      "enum": [
        "owner",
        "admin",
        "developer",
        "reader",
        "external"
      ],
      "description": "On the whole organization (developer by default); external sees only what it is granted. People who only use your internal apps: no invitation, Access on the app (grant_role, role access)."
    },
    "project": {
      "type": "string",
      "description": "The app where the role is given; without it: the whole organization."
    },
    "reason": {
      "type": "string",
      "description": "The reason for the assignment (in the log); \"member of the organization\" by default."
    },
    "resend": {
      "type": "boolean",
      "description": "true: sends the pending invitation of this address again, without changing anything else."
    }
  },
  "required": [
    "email"
  ],
  "additionalProperties": false
}
βšͺgrant_role(organization, who, role, scope, until, ...)

Grants a role to an identity (a person, a group, a service account, an app) on a scope, until a date; only what one holds oneself, never to oneself.

Input Schema

{
  "type": "object",
  "properties": {
    "organization": {
      "type": "string",
      "description": "The organization."
    },
    "who": {
      "type": "string",
      "description": "An address, group:<name>, service_account:<name>, app:<project>/<service> or task:<project>/<task>."
    },
    "role": {
      "type": "string",
      "description": "A built-in role (owner, admin, developer, reader, access, data-reader, connection-caller, connection-writer) or one of the organization's (review_access { view: \"roles\" })."
    },
    "scope": {
      "type": "object",
      "additionalProperties": false,
      "description": "{}: the organization; otherwise down to a table, or a connection.",
      "properties": {
        "type": {
          "type": "string",
          "enum": [
            "organization"
          ],
          "description": "The whole organization."
        },
        "project": {
          "type": "string",
          "description": "Project name."
        },
        "environment": {
          "type": "string",
          "description": "The environment."
        },
        "database": {
          "type": "string",
          "description": "Database name."
        },
        "schema": {
          "type": "string",
          "description": "PostgreSQL schema."
        },
        "table": {
          "type": "string",
          "description": "\"schema.table\"."
        },
        "columns": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "maxItems": 1600,
          "description": "The table's columns."
        },
        "connection": {
          "type": "string",
          "description": "Connection name."
        },
        "paths": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "maxItems": 100,
          "description": "Patterns, e.g. \"/notes/**\"."
        }
      }
    },
    "until": {
      "type": "string",
      "description": "End date (included): 2026-11-30."
    },
    "days": {
      "type": "integer",
      "minimum": 1,
      "maximum": 3650,
      "description": "Duration, in days."
    },
    "reason": {
      "type": "string",
      "description": "Why (\"Q4 audit\"): it goes to the log and is read in the sentence."
    }
  },
  "required": [
    "who",
    "role",
    "scope",
    "reason"
  ],
  "additionalProperties": false
}
πŸ”΄revoke_role(organization, assignment, reason)

Removes an assignment at once; the last owner stays.

Input Schema

{
  "type": "object",
  "properties": {
    "organization": {
      "type": "string",
      "description": "The organization."
    },
    "assignment": {
      "type": "string",
      "description": "The assignment's id."
    },
    "reason": {
      "type": "string",
      "description": "Why (in the log)."
    }
  },
  "required": [
    "assignment",
    "reason"
  ],
  "additionalProperties": false
}
🟑create_token(scope, project, organization, name, permissions, ...)

Creates an API token for a project or for the organization, with its permissions, its environments and its lifetime; it is returned only once. Not by an agent connected through OAuth: a person creates it in while.

Input Schema

{
  "type": "object",
  "properties": {
    "scope": {
      "type": "string",
      "enum": [
        "project",
        "organization"
      ],
      "default": "project",
      "description": "A project, or the organization."
    },
    "project": {
      "type": "string",
      "description": "The project."
    },
    "organization": {
      "type": "string",
      "description": "For an organization token: its name; optional with an organization token."
    },
    "name": {
      "type": "string",
      "description": "What it is for (\"GitLab CI\")."
    },
    "permissions": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "deploy and read by default."
    },
    "environments": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "maxItems": 20,
      "description": "Where it can act (production, previews, or names); without a list, everywhere."
    },
    "days": {
      "type": "integer",
      "minimum": 0,
      "maximum": 365,
      "default": 30,
      "description": "Lifetime in days (30 by default, 0 without expiry)."
    }
  },
  "additionalProperties": false
}
πŸ”΄update_connection(organization, connection, method, pattern, approve_each_call, ...)

One setting per call on a connection: method and pattern request one more rule (pending approval); lock: true ends its learning (pending approval: the rules drawn from the observed calls apply, the rest is refused); caller, window and calls set a call limit; remove_limit removes a limit.

Input Schema

{
  "type": "object",
  "properties": {
    "organization": {
      "type": "string",
      "description": "The organization."
    },
    "connection": {
      "type": "string",
      "description": "Connection name (list_connections)."
    },
    "method": {
      "type": "string",
      "enum": [
        "GET",
        "HEAD",
        "POST",
        "PUT",
        "PATCH",
        "DELETE",
        "OPTIONS",
        "*"
      ],
      "description": "HTTP method."
    },
    "pattern": {
      "type": "string",
      "description": "Path, e.g. /api/v1/slots/*/close."
    },
    "approve_each_call": {
      "type": "boolean",
      "default": false,
      "description": "true: each call waits for an approval."
    },
    "read": {
      "type": "boolean",
      "description": "A POST that only reads."
    },
    "reason": {
      "type": "string",
      "description": "Why this rule, in one sentence."
    },
    "lock": {
      "type": "boolean",
      "description": "true: end the learning."
    },
    "caller": {
      "type": "string",
      "description": "Who is limited (agent:<id>, group:finance, app:boutique/web…)."
    },
    "window": {
      "type": "string",
      "enum": [
        "minute",
        "hour",
        "day",
        "month"
      ],
      "description": "The window."
    },
    "calls": {
      "type": "integer",
      "minimum": 1,
      "maximum": 100000000,
      "description": "The number of calls allowed per window."
    },
    "remove_limit": {
      "type": "string",
      "description": "The limit to remove (its id, list_connections { view: \"limits\" })."
    }
  },
  "additionalProperties": false
}
πŸ”΄set_connection_binding(organization, connection, binding, reason, resume, ...)

Without binding, requests (pending approval) that a production app call a federated connection (OIDC): while signs a short token for it, without a secret; federation must be enabled for the organization. With binding: resume: true resumes a suspended binding; approve_production_deploys checks or unchecks the approval of its production deploys.

Input Schema

{
  "type": "object",
  "properties": {
    "organization": {
      "type": "string",
      "description": "The organization."
    },
    "connection": {
      "type": "string",
      "description": "Name of the federated connection."
    },
    "binding": {
      "type": "string",
      "description": "The id of the binding."
    },
    "reason": {
      "type": "string",
      "description": "Why (in the log)."
    },
    "resume": {
      "type": "boolean",
      "description": "true: resume the binding."
    },
    "approve_production_deploys": {
      "type": "boolean",
      "description": "true: its production deploys wait for an approval; false: they do not."
    },
    "project": {
      "type": "string",
      "description": "The app's project."
    },
    "caller": {
      "type": "string",
      "description": "A request: the app's service (web), or \"task:<name>\"."
    }
  },
  "required": [
    "connection"
  ],
  "additionalProperties": false
}

Community

Rate this Server

Evidence

Recent observations

verifiedversion not recorded44 tools
verifiedversion not recorded44 tools