Evidence row 568723

What was observed

{
  "count": 21,
  "tools": [
    {
      "description": "What Termalin's monitoring says is wrong with the user's servers right now (disk filling up, memory or load pinned, a failed service, a restarting container, a certificate about to expire, a server offline), plus what cleared in the last seven days. Start here when asked how the servers are doing. Covers servers with metrics switched on.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {},
        "type": "object"
      },
      "name": "alerts_list"
    },
    {
      "description": "Make an encrypted backup of one of the user's servers now, through Termalin's backup job for that server, and wait for it (up to about a minute; a longer one keeps running and shows up in backup_list). Call it BEFORE a risky change — a migration, a config rewrite, a bulk delete — and say so in 'label'. The server needs a backup job set up in the Termalin cabinet (that is where the owner chooses the paths and the encryption key); without one this tool explains how to add it. Uses the owner's storage quota, and keeps the job's 'keep last' count: when that many archives exist, the oldest one is removed.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "host": {
            "description": "Server id or exact name from hosts_list",
            "type": "string"
          },
          "job": {
            "description": "Name of the backup job when the server has several (default: the first)",
            "type": "string"
          },
          "label": {
            "description": "Why this backup is being made, e.g. 'before upgrading postgres'",
            "type": "string"
          }
        },
        "required": [
          "host"
        ],
        "type": "object"
      },
      "name": "backup_create"
    },
    {
      "description": "The backup jobs and recent archives of one of the user's servers: when each ran, whether it succeeded, how big it is and where it is stored. Use it to check that a backup exists before a risky change, or to see whether last night's backup worked.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "host": {
            "description": "Server id or exact name from hosts_list",
            "type": "string"
          }
        },
        "required": [
          "host"
        ],
        "type": "object"
      },
      "name": "backup_list"
    },
    {
      "description": "Run a database query on one of your servers — passwordless. It executes the engine's own client on the host over Termalin's keyless tunnel, using the database's local trust (Postgres peer auth via `sudo -u postgres`, MySQL/MariaDB unix-socket via `sudo mysql`, redis-cli, mongosh, sqlite3) — so no database password is needed or stored anywhere. Read-only by default: only SELECT/SHOW-style statements run unless allowWrites is set (full-access keys only). SQL engines return CSV/TSV with a header. For MongoDB pass a shell expression, e.g. db.products.find({}).limit(20).toArray().",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "allowWrites": {
            "description": "Allow a non-read statement (full-access keys only; default false)",
            "type": "boolean"
          },
          "database": {
            "description": "Database name (for sqlite: the .db file path)",
            "type": "string"
          },
          "engine": {
            "description": "Database engine on that server (default postgres)",
            "enum": [
              "postgres",
              "mysql",
              "mariadb",
              "redis",
              "mongodb",
              "sqlite"
            ],
            "type": "string"
          },
          "host": {
            "description": "Server id from hosts_list",
            "type": "string"
          },
          "query": {
            "description": "The statement / command / expression to run",
            "type": "string"
          },
          "timeoutSeconds": {
            "description": "Max seconds to wait (default 60). Calls longer than about 90 seconds are usually cut off by the network before they answer — run long jobs in the background instead.",
            "type": "number"
          },
          "username": {
            "description": "SSH login user (defaults to the tunnel's user, else root)",
            "type": "string"
          }
        },
        "required": [
          "host",
          "query"
        ],
        "type": "object"
      },
      "name": "data_query"
    },
    {
      "description": "Describe one table of a database on one of your servers: its columns with type, whether they can be empty, default value and primary key. Call it before writing a query against a table you have not seen. Works for postgres, mysql, mariadb and sqlite.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "database": {
            "description": "Database name (for sqlite: the .db file path)",
            "type": "string"
          },
          "engine": {
            "description": "Database engine on that server (default postgres)",
            "enum": [
              "postgres",
              "mysql",
              "mariadb",
              "sqlite"
            ],
            "type": "string"
          },
          "host": {
            "description": "Server id (or exact name) from hosts_list",
            "type": "string"
          },
          "table": {
            "description": "Table name, optionally with its schema (e.g. users or public.users)",
            "type": "string"
          },
          "username": {
            "description": "SSH login user (defaults to the server's user, else root)",
            "type": "string"
          }
        },
        "required": [
          "host",
          "table"
        ],
        "type": "object"
      },
      "name": "data_schema"
    },
    {
      "description": "List the tables / collections / keys of a database on one of your servers — passwordless, over the same local-client path as data_query.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "database": {
            "description": "Database name (for sqlite: the .db file path)",
            "type": "string"
          },
          "engine": {
            "description": "Database engine on that server (default postgres)",
            "enum": [
              "postgres",
              "mysql",
              "mariadb",
              "redis",
              "mongodb",
              "sqlite"
            ],
            "type": "string"
          },
          "host": {
            "description": "Server id from hosts_list",
            "type": "string"
          },
          "username": {
            "description": "SSH login user (defaults to the tunnel's user, else root)",
            "type": "string"
          }
        },
        "required": [
          "host"
        ],
        "type": "object"
      },
      "name": "data_tables"
    },
    {
      "description": "Generate a strong random password — handy when creating a user or setting a password on a server. Returns the password only; nothing is stored.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "length": {
            "description": "length (default 20, 8-128)",
            "type": "integer"
          }
        },
        "type": "object"
      },
      "name": "generate_password"
    },
    {
      "description": "List the servers reachable through Termalin (your tunnel agents). Returns id, name, whether the server is online, the user commands run as, when it was last seen, its country, ip (the public address the server's Connector connects from; null until it has connected), and ownerNote — what the owner wrote about that server for you (what it is, what to leave alone); follow it. 'policy' says what you may do there: full, allowlist (only listed commands; allowedCommands holds the server's list, no file writes) or readonly (no commands, no file writes). Use the id (or the exact name) as 'host' in the other tools.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {},
        "type": "object"
      },
      "name": "hosts_list"
    },
    {
      "description": "List the recent background jobs on a server (newest first): id, state, start time and the command.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "host": {
            "description": "Server id (or exact name) from hosts_list",
            "type": "string"
          },
          "username": {
            "description": "Login user whose jobs to list (defaults to the server's user, else root)",
            "type": "string"
          }
        },
        "required": [
          "host"
        ],
        "type": "object"
      },
      "name": "job_list"
    },
    {
      "description": "Start a long-running shell command on a server in the background and return a job id right away. Use it for anything that can take more than about a minute — package installs, builds, backups, migrations, large downloads. The job keeps running after this call returns and survives the connection closing; its output goes to a log you read with job_status. The command runs from the login user's home directory.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "command": {
            "description": "Shell command to run in the background",
            "type": "string"
          },
          "host": {
            "description": "Server id (or exact name) from hosts_list",
            "type": "string"
          },
          "username": {
            "description": "Login user (defaults to the server's user, else root). Use the same one for job_status/job_stop.",
            "type": "string"
          }
        },
        "required": [
          "host",
          "command"
        ],
        "type": "object"
      },
      "name": "job_start"
    },
    {
      "description": "Check a background job started with job_start: whether it is still running or finished (with its exit code), when it started, and the last lines of its output.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "host": {
            "description": "Server id (or exact name) from hosts_list",
            "type": "string"
          },
          "job": {
            "description": "Job id returned by job_start",
            "type": "string"
          },
          "lines": {
            "description": "How many last lines of output to return (default 40, at most 500)",
            "type": "integer"
          },
          "username": {
            "description": "Login user the job was started as (if one was given to job_start)",
            "type": "string"
          }
        },
        "required": [
          "host",
          "job"
        ],
        "type": "object"
      },
      "name": "job_status"
    },
    {
      "description": "Stop a background job started with job_start (asks it to terminate, then forces it after two seconds). Does nothing if the job already finished.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "host": {
            "description": "Server id (or exact name) from hosts_list",
            "type": "string"
          },
          "job": {
            "description": "Job id returned by job_start",
            "type": "string"
          },
          "username": {
            "description": "Login user the job was started as (if one was given to job_start)",
            "type": "string"
          }
        },
        "required": [
          "host",
          "job"
        ],
        "type": "object"
      },
      "name": "job_stop"
    },
    {
      "description": "Numbers Termalin's monitoring collects from the user's servers every minute, without running anything now: CPU, memory, disk, load, network, the busiest processes, failed services, containers, certificates. Without `host`: one line per server with its latest numbers. With `host`: that server's latest sample in full and the average and peak over the last `hours` (default 6). Use it for 'how is the server doing' and 'what happened at night' before reaching for ssh_exec. Covers servers with metrics switched on.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "host": {
            "description": "Server name or id from hosts_list. Leave out for all servers.",
            "type": "string"
          },
          "hours": {
            "description": "How far back to summarise, in hours. Default 6.",
            "type": "number"
          }
        },
        "type": "object"
      },
      "name": "server_metrics"
    },
    {
      "description": "List a directory on one of your servers over SFTP. Returns each entry's name, whether it's a directory, size and modified time. Runs keyless over Termalin's tunnel, like ssh_exec.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "host": {
            "description": "Server id from hosts_list",
            "type": "string"
          },
          "path": {
            "description": "Directory to list (default the login home, \".\")",
            "type": "string"
          },
          "username": {
            "description": "Login user (defaults to the tunnel's user, else root)",
            "type": "string"
          }
        },
        "required": [
          "host"
        ],
        "type": "object"
      },
      "name": "sftp_list"
    },
    {
      "description": "Read a text file from one of your servers over SFTP and return its contents. Files over 512 KB or non-text (binary) files are refused — use ssh_exec (e.g. sed/tail) for those.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "host": {
            "description": "Server id from hosts_list",
            "type": "string"
          },
          "path": {
            "description": "Absolute or home-relative file path",
            "type": "string"
          },
          "username": {
            "description": "Login user (defaults to the tunnel's user, else root)",
            "type": "string"
          }
        },
        "required": [
          "host",
          "path"
        ],
        "type": "object"
      },
      "name": "sftp_read"
    },
    {
      "description": "Create or overwrite a text file on one of your servers over SFTP. 'content' is written as UTF-8. Capped at 512 KB; for binary uploads use a terminal/scp instead.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "content": {
            "description": "UTF-8 text to write",
            "type": "string"
          },
          "host": {
            "description": "Server id from hosts_list",
            "type": "string"
          },
          "path": {
            "description": "Destination file path (created or overwritten)",
            "type": "string"
          },
          "username": {
            "description": "Login user (defaults to the tunnel's user, else root)",
            "type": "string"
          }
        },
        "required": [
          "host",
          "path",
          "content"
        ],
        "type": "object"
      },
      "name": "sftp_write"
    },
    {
      "description": "Run a single shell command on one of your servers and return its combined output and exit code. Runs keyless over Termalin's tunnel — no SSH key, and the server needs no open inbound port. Each call is a fresh shell (cd does not persist — chain with &&). Keep a call under about 90 seconds: for anything longer (installs, builds, backups) use job_start and check on it with job_status.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "command": {
            "description": "Shell command to execute",
            "type": "string"
          },
          "host": {
            "description": "Server id from hosts_list",
            "type": "string"
          },
          "timeoutSeconds": {
            "description": "Max seconds to wait (default 60). Calls longer than about 90 seconds are usually cut off by the network before they answer — run long jobs in the background instead.",
            "type": "number"
          },
          "username": {
            "description": "Login user (defaults to the tunnel's user, else root)",
            "type": "string"
          }
        },
        "required": [
          "host",
          "command"
        ],
        "type": "object"
      },
      "name": "ssh_exec"
    },
    {
      "description": "Run the same shell command on several of your servers at once and return each server's output and exit code. Use it to compare or check a fleet (disk space, versions, a service's state) in one call instead of one call per server. Up to 10 servers; the same 90-second limit as ssh_exec applies.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "command": {
            "description": "Shell command to execute on each server",
            "type": "string"
          },
          "hosts": {
            "description": "Server ids (or exact names) from hosts_list",
            "items": {
              "type": "string"
            },
            "maxItems": 10,
            "minItems": 1,
            "type": "array"
          },
          "timeoutSeconds": {
            "description": "Max seconds to wait per server (default 60, at most 80)",
            "type": "number"
          }
        },
        "required": [
          "hosts",
          "command"
        ],
        "type": "object"
      },
      "name": "ssh_exec_many"
    },
    {
      "description": "Put an internal web service of one of the user's servers into the owner's Termalin cabinet as an 'internal site': a dashboard, admin panel or app that listens only inside that server's network (e.g. localhost:3000 on the server, or 10.0.0.5:8080 next to it). Termalin gives it its own address that only the owner can open, signed in to Termalin, through the server's Connector — nothing is exposed to the internet and no port is opened. Only private addresses are accepted. Returns the link's id, open_url and url. Give the user open_url to open the site (it signs them in to Termalin first). The <slug>.termal.ink address in url shows 'This link doesn't work' to anyone without a session, the owner included, until opened from the account. This tool does not open or read the site, and it can't give anyone else access: sharing with other people is done by the owner in the cabinet. An account can hold a limited number of internal sites; when it is reached, ask the owner to remove one (web_link_delete).",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "https_inside": {
            "description": "The site itself speaks https (default false)",
            "type": "boolean"
          },
          "name": {
            "description": "A short name for the owner's list, e.g. 'Grafana' (optional)",
            "type": "string"
          },
          "server": {
            "description": "Server id (or exact name) from hosts_list — the server whose Connector reaches the site",
            "type": "string"
          },
          "target": {
            "description": "host:port of the site as seen from that server, e.g. localhost:3000 or 10.0.0.5:8080 (a path may follow, e.g. 10.0.0.5:3000/grafana/)",
            "type": "string"
          }
        },
        "required": [
          "server",
          "target"
        ],
        "type": "object"
      },
      "name": "web_link_create"
    },
    {
      "description": "Remove an internal site from the owner's Termalin cabinet by its id (from web_link_list). Its address stops working at once, for the owner and for anyone the owner shared it with. The service on the server is not touched.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "id": {
            "description": "Internal site id from web_link_list or web_link_create",
            "type": "string"
          }
        },
        "required": [
          "id"
        ],
        "type": "object"
      },
      "name": "web_link_delete"
    },
    {
      "description": "The internal sites in the owner's Termalin cabinet on the servers you can reach: id, name, server, target, open_url, url, who added it (the owner or an AI app), when, and how many people the owner shared it with. Give the user open_url to open a site (it signs them in to Termalin first); the url address shows 'This link doesn't work' without a session, the owner included, until opened from the account. Sharing is managed by the owner in the cabinet.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {},
        "type": "object"
      },
      "name": "web_link_list"
    }
  ]
}

What the leaf hashes

{"body":"271986b089326c1800d192e1c21652951c27eb2d77e09d82e28b10bb22fd56ce","id":568723,"kind":"mcp.tools","method":"probe.mcp/1","observed_us":1793139100875135,"prev":null,"subject":"ead3151d-5890-4880-8b0d-5e5a7be51089","subject_kind":"endpoint"}

Proof

Its day has not closed yet. A day closes ten minutes after midnight UTC; the proof appears here then.