@francescomalatesta/laravel-forge-mcp 0.12.0 → 0.13.0

package/README.md

@@ -106,6 +106,11 @@ npm run build
 | `forge_create_certificate` | sites | Let's Encrypt, existing, CSR or cloned certificate, waiting until installed |
 | `forge_run_certificate_action` | sites | Activate or deactivate a certificate |
 | `forge_delete_certificate` | sites | Delete a certificate |
+| `forge_list_package_credentials` | sites | Credentials for private Composer repositories and npm registries (secrets hidden) |
+| `forge_set_package_credentials` | sites | Add or replace Composer or npm credentials |
+| `forge_delete_package_credentials` | sites | Remove Composer or npm credentials |
+| `forge_get_load_balancer` | sites | Servers a load-balanced site sends traffic to |
+| `forge_update_load_balancer` | sites | Replace the nodes and balancing method, take nodes out of rotation |
 | `forge_run_service_action` | servers | Restart or stop Nginx, MySQL, Postgres, Redis, Supervisor; restart or reload PHP-FPM |
 | `forge_run_server_action` | servers | Reboot or power-cycle a server |
 | `forge_get_server_log` | servers | End of a server log (Nginx, PHP-FPM, MySQL, cron, daemons) |
@@ -113,6 +118,10 @@ npm run build
 | `forge_update_server` | servers | Rename, change IP addresses, timezone or tags |
 | `forge_get_server_network` | servers | Servers that can reach each other on the private network |
 | `forge_update_server_network` | servers | Set the server network |
+| `forge_list_nginx_templates` | servers | Custom Nginx templates for new sites |
+| `forge_create_nginx_template` | servers | Save an Nginx template |
+| `forge_update_nginx_template` | servers | Rename or replace an Nginx template |
+| `forge_delete_nginx_template` | servers | Delete an Nginx template |
 | `forge_list_archived_servers` | servers | Archived servers |
 | `forge_archive_server` | servers | Archive a server (Forge stops managing it) |
 | `forge_unarchive_server` | servers | Restore an archived server |
@@ -192,6 +201,13 @@ npm run build
 | `forge_delete_ssh_key` | security | Revoke an SSH key |
 | `forge_get_server_public_key` | security | The server's own public key (for Git providers, other servers) |
 | `forge_regenerate_server_key` | security | Replace the server's own key pair |
+| `forge_list_heartbeats` | monitoring | Heartbeats of a site and whether they are missing |
+| `forge_create_heartbeat` | monitoring | Alert when a scheduled task stops pinging |
+| `forge_update_heartbeat` | monitoring | Change name, schedule or grace period |
+| `forge_delete_heartbeat` | monitoring | Delete a heartbeat |
+| `forge_list_monitors` | monitoring | CPU, disk and memory monitors and their alert state |
+| `forge_create_monitor` | monitoring | Alert by email when a metric crosses a threshold |
+| `forge_delete_monitor` | monitoring | Remove a monitor |
 | `forge_get_site_integrations` | integrations | Horizon, Octane, Reverb, Pulse, Inertia SSR, scheduler and maintenance mode status |
 | `forge_enable_site_integration` | integrations | Enable an integration (e.g. put the site in maintenance mode) and wait until it is active |
 | `forge_disable_site_integration` | integrations | Disable an integration (e.g. bring the site back up) |

package/dist/tools/heartbeats/create-heartbeat.js

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+import { flattenSingle } from '../../forge/jsonapi.js';
+import { defineTool } from '../define-tool.js';
+import { SITE_NOT_FOUND_HINT, siteScopeInput } from '../shared/site-scope.js';
+import { REDACTED } from '../shared/secrets.js';
+import { cronInput, formatHeartbeat, frequencyInput, gracePeriodInput, heartbeatOutput, heartbeatsPath, scheduleBody } from './shared.js';
+export const createHeartbeat = defineTool({
+    name: 'forge_create_heartbeat',
+    title: 'Create heartbeat',
+    description: 'Create a heartbeat: Forge alerts when the job does not request its ping URL on schedule (e.g. `->thenPing($url)` on a Laravel scheduled task). Pass `frequency` or `cron`.',
+    toolset: 'monitoring',
+    operations: ['organizations.servers.sites.heartbeats.store'],
+    permissions: ['site:manage-heartbeats'],
+    readOnly: false,
+    destructive: false,
+    idempotent: false,
+    notFoundHint: SITE_NOT_FOUND_HINT,
+    inputSchema: {
+        ...siteScopeInput,
+        name: z.string().min(1).max(255).describe('Name, e.g. "Nightly reports".'),
+        frequency: frequencyInput.optional(),
+        cron: cronInput.optional(),
+        grace_period: gracePeriodInput.default(5),
+    },
+    outputSchema: {
+        heartbeat: heartbeatOutput,
+    },
+    async handler(args, { client, config, organization, signal }) {
+        const response = await client.post(heartbeatsPath(organization(args.organization), args.server, args.site), {
+            body: { name: args.name, grace_period: args.grace_period, ...scheduleBody(args.frequency, args.cron) },
+            signal,
+        });
+        const heartbeat = formatHeartbeat(flattenSingle(response.data), config.allowSecrets);
+        return {
+            structured: { heartbeat },
+            summary: `Created heartbeat ${heartbeat.name} (ID ${heartbeat.id}).${heartbeat.ping_url === REDACTED ? ' Its ping URL is hidden: enable FORGE_ALLOW_SECRETS or copy it from the Forge dashboard.' : ` Ping URL: ${heartbeat.ping_url}`}`,
+        };
+    },
+});

package/dist/tools/heartbeats/delete-heartbeat.js

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { defineTool } from '../define-tool.js';
+import { siteScopeInput } from '../shared/site-scope.js';
+import { HEARTBEAT_NOT_FOUND_HINT, heartbeatInput, heartbeatsPath } from './shared.js';
+export const deleteHeartbeat = defineTool({
+    name: 'forge_delete_heartbeat',
+    title: 'Delete heartbeat',
+    description: 'Delete a heartbeat: Forge stops alerting when the job does not ping.',
+    toolset: 'monitoring',
+    operations: ['organizations.servers.sites.heartbeats.destroy'],
+    permissions: ['site:manage-heartbeats'],
+    readOnly: false,
+    destructive: true,
+    idempotent: true,
+    notFoundHint: HEARTBEAT_NOT_FOUND_HINT,
+    inputSchema: {
+        ...siteScopeInput,
+        heartbeat: heartbeatInput,
+    },
+    outputSchema: {
+        deleted: z.boolean(),
+    },
+    async handler(args, { client, organization, signal }) {
+        await client.delete(`${heartbeatsPath(organization(args.organization), args.server, args.site)}/${encodeURIComponent(String(args.heartbeat))}`, {
+            signal,
+        });
+        return { structured: { deleted: true }, summary: `Deleted heartbeat ${args.heartbeat}.` };
+    },
+});

package/dist/tools/heartbeats/list-heartbeats.js

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+import { flattenCollection } from '../../forge/jsonapi.js';
+import { defineTool } from '../define-tool.js';
+import { readResource } from '../shared/read.js';
+import { paginationInput, paginationOutput, paginationSummary } from '../shared/schemas.js';
+import { SITE_NOT_FOUND_HINT, siteScopeInput } from '../shared/site-scope.js';
+import { formatHeartbeat, heartbeatInput, heartbeatOutput, heartbeatsPath } from './shared.js';
+export const listHeartbeats = defineTool({
+    name: 'forge_list_heartbeats',
+    title: 'List heartbeats',
+    description: 'List the heartbeats of a site (scheduled tasks that must ping Forge regularly) with their status: missing means the job stopped running. Get one with `heartbeat`.',
+    toolset: 'monitoring',
+    operations: ['organizations.servers.sites.heartbeats.index', 'organizations.servers.sites.heartbeats.show'],
+    permissions: ['server:view'],
+    readOnly: true,
+    notFoundHint: SITE_NOT_FOUND_HINT,
+    inputSchema: {
+        ...siteScopeInput,
+        heartbeat: heartbeatInput.optional().describe('Return only this heartbeat.'),
+        ...paginationInput,
+    },
+    outputSchema: {
+        heartbeats: z.array(heartbeatOutput),
+        ...paginationOutput,
+    },
+    async handler(args, { client, config, organization, signal }) {
+        const base = heartbeatsPath(organization(args.organization), args.server, args.site);
+        const format = (flat) => formatHeartbeat(flat, config.allowSecrets);
+        if (args.heartbeat !== undefined) {
+            const heartbeat = format(await readResource(client, `${base}/${encodeURIComponent(String(args.heartbeat))}`, signal));
+            return { structured: { heartbeats: [heartbeat], next_cursor: null, has_more: false }, summary: `Heartbeat ${heartbeat.name} is ${heartbeat.status}.` };
+        }
+        const response = await client.get(base, { query: { page: { size: args.page_size, cursor: args.cursor } }, signal });
+        const page = flattenCollection(response.data);
+        const heartbeats = page.items.map(format);
+        const missing = heartbeats.filter((heartbeat) => heartbeat.status === 'missing');
+        return {
+            structured: { heartbeats, next_cursor: page.nextCursor, has_more: page.nextCursor !== null },
+            summary: heartbeats.length === 0
+                ? 'No heartbeats found.'
+                : `Found ${heartbeats.length} heartbeat(s)${missing.length > 0 ? `; missing: ${missing.map((h) => h.name).join(', ')}` : ''}.${paginationSummary(page.nextCursor)}`,
+        };
+    },
+});

package/dist/tools/heartbeats/shared.js

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import { ToolInputError } from '../errors.js';
+import { redact } from '../shared/secrets.js';
+import { idInput, pick } from '../shared/schemas.js';
+import { sitePath } from '../shared/site-scope.js';
+export function heartbeatsPath(org, server, site) {
+    return `${sitePath(org, server, site)}/heartbeats`;
+}
+export const heartbeatInput = idInput('Heartbeat ID. Use forge_list_heartbeats to find it.');
+export const HEARTBEAT_NOT_FOUND_HINT = 'Check the heartbeat ID with forge_list_heartbeats.';
+/** Minutes between expected pings (-1 = custom cron). */
+const FREQUENCIES = [1, 5, 10, 30, 60, 1440, 10080, 312480];
+const GRACE_PERIODS = [1, 2, 5, 10, 30, 60];
+export const frequencyInput = z.literal(FREQUENCIES).describe('Minutes between expected pings: 1, 5, 10, 30, 60, 1440 (daily), 10080 (weekly) or 312480. Use `cron` instead for other schedules.');
+export const cronInput = z.string().min(1).describe('Cron expression of the expected pings, e.g. "0 3 * * *" (instead of `frequency`).');
+export const gracePeriodInput = z.literal(GRACE_PERIODS).describe('Minutes of delay tolerated before the heartbeat is reported missing: 1, 2, 5, 10, 30 or 60.');
+/** Maps `frequency` / `cron` to the API fields (frequency -1 means custom). */
+export function scheduleBody(frequency, cron) {
+    if ((frequency === undefined) === (cron === undefined))
+        throw new ToolInputError('Pass either `frequency` or `cron`.');
+    return cron === undefined ? { frequency } : { frequency: -1, custom_frequency: cron };
+}
+const FIELDS = ['id', 'name', 'status', 'frequency', 'custom_frequency', 'grace_period', 'ping_url'];
+export const heartbeatOutput = z.looseObject({
+    id: z.string(),
+    name: z.string().nullable(),
+    status: z.string().nullable().describe('pending (no ping yet), beating or missing.'),
+    frequency: z.number().nullable().describe('Minutes between expected pings; -1 = custom cron.'),
+    custom_frequency: z.string().nullable(),
+    grace_period: z.number().nullable(),
+    ping_url: z.string().nullable().describe('URL the job must request after each run (hidden unless secrets are allowed).'),
+});
+/** The ping URL lets anyone report the job as alive: it is a secret. */
+export function formatHeartbeat(flat, allowSecrets) {
+    return redact(pick(flat, FIELDS), ['ping_url'], allowSecrets);
+}

package/dist/tools/heartbeats/update-heartbeat.js

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+import { flattenSingle } from '../../forge/jsonapi.js';
+import { defineTool } from '../define-tool.js';
+import { ToolInputError } from '../errors.js';
+import { readResource } from '../shared/read.js';
+import { siteScopeInput } from '../shared/site-scope.js';
+import { cronInput, formatHeartbeat, frequencyInput, gracePeriodInput, HEARTBEAT_NOT_FOUND_HINT, heartbeatInput, heartbeatOutput, heartbeatsPath, scheduleBody, } from './shared.js';
+export const updateHeartbeat = defineTool({
+    name: 'forge_update_heartbeat',
+    title: 'Update heartbeat',
+    description: 'Change the name, schedule (`frequency` or `cron`) or grace period of a heartbeat. Fields not passed keep their value.',
+    toolset: 'monitoring',
+    operations: ['organizations.servers.sites.heartbeats.update', 'organizations.servers.sites.heartbeats.show'],
+    permissions: ['site:manage-heartbeats', 'server:view'],
+    readOnly: false,
+    destructive: false,
+    idempotent: true,
+    notFoundHint: HEARTBEAT_NOT_FOUND_HINT,
+    inputSchema: {
+        ...siteScopeInput,
+        heartbeat: heartbeatInput,
+        name: z.string().min(1).max(255).optional().describe('New name.'),
+        frequency: frequencyInput.optional(),
+        cron: cronInput.optional(),
+        grace_period: gracePeriodInput.optional(),
+    },
+    outputSchema: {
+        heartbeat: heartbeatOutput,
+    },
+    async handler(args, { client, config, organization, signal }) {
+        if (args.name === undefined && args.frequency === undefined && args.cron === undefined && args.grace_period === undefined) {
+            throw new ToolInputError('Pass at least one setting to change.');
+        }
+        const path = `${heartbeatsPath(organization(args.organization), args.server, args.site)}/${encodeURIComponent(String(args.heartbeat))}`;
+        const current = await readResource(client, path, signal);
+        const schedule = args.frequency !== undefined || args.cron !== undefined
+            ? scheduleBody(args.frequency, args.cron)
+            : current.frequency === -1
+                ? { frequency: -1, custom_frequency: current.custom_frequency }
+                : { frequency: current.frequency };
+        const response = await client.put(path, {
+            body: { name: args.name ?? current.name, grace_period: args.grace_period ?? current.grace_period, ...schedule },
+            signal,
+        });
+        const heartbeat = formatHeartbeat(flattenSingle(response.data), config.allowSecrets);
+        return { structured: { heartbeat }, summary: `Updated heartbeat ${heartbeat.name}.` };
+    },
+});

package/dist/tools/load-balancing/get-load-balancer.js

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { defineTool } from '../define-tool.js';
+import { siteScopeInput } from '../shared/site-scope.js';
+import { nodeOutput, nodesPath, readNodes } from './shared.js';
+export const getLoadBalancer = defineTool({
+    name: 'forge_get_load_balancer',
+    title: 'Get load balancer nodes',
+    description: 'List the servers a load-balanced site sends traffic to, with weight, port and backup/down flags.',
+    toolset: 'sites',
+    operations: ['organizations.servers.sites.load-balancing-nodes.index'],
+    permissions: ['site:manage-project'],
+    readOnly: true,
+    notFoundHint: 'Check the load balancer server and site IDs with forge_list_sites.',
+    inputSchema: {
+        ...siteScopeInput,
+    },
+    outputSchema: {
+        nodes: z.array(nodeOutput),
+    },
+    async handler(args, { client, organization, signal }) {
+        const nodes = await readNodes(client, nodesPath(organization(args.organization), args.server, args.site), signal);
+        return {
+            structured: { nodes },
+            summary: nodes.length === 0
+                ? 'This site has no load balancing nodes.'
+                : `Traffic goes to server(s) ${nodes.map((n) => `${n.server_id} (weight ${n.weight}${n.down ? ', down' : ''}${n.backup ? ', backup' : ''})`).join(', ')}.`,
+        };
+    },
+});

package/dist/tools/load-balancing/shared.js

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { flattenCollection } from '../../forge/jsonapi.js';
+import { sitePath } from '../shared/site-scope.js';
+export function nodesPath(org, server, site) {
+    return `${sitePath(org, server, site)}/load-balancing-nodes`;
+}
+export const nodeOutput = z.looseObject({
+    server_id: z.string().nullable().describe('Server receiving traffic.'),
+    port: z.number().nullable(),
+    weight: z.number().nullable().describe('Relative share of traffic.'),
+    backup: z.boolean().nullable().describe('Only used when the other servers are unavailable.'),
+    down: z.boolean().nullable().describe('Out of rotation.'),
+});
+export function formatNode(flat) {
+    return {
+        server_id: flat.server_id === undefined || flat.server_id === null ? null : String(flat.server_id),
+        port: flat.port ?? null,
+        weight: flat.weight ?? null,
+        backup: flat.backup ?? null,
+        down: flat.down ?? null,
+    };
+}
+/** Every node of the load balancer (one page of 100 covers any realistic pool). */
+export async function readNodes(client, path, signal) {
+    const response = await client.get(path, { query: { page: { size: 100 } }, signal });
+    return flattenCollection(response.data).items.map(formatNode);
+}

package/dist/tools/load-balancing/update-load-balancer.js

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+import { defineTool } from '../define-tool.js';
+import { operationOutput, outcome, queued, waitFor, waitInput } from '../shared/async.js';
+import { siteScopeInput } from '../shared/site-scope.js';
+import { nodeOutput, nodesPath, readNodes } from './shared.js';
+const CHECK_WITH = 'forge_get_load_balancer';
+const node = z.object({
+    server_id: z.number().int().describe('Server receiving traffic.'),
+    port: z.number().int().min(1).max(65535).optional(),
+    weight: z.number().int().min(1).default(1).describe('Relative share of traffic.'),
+    backup: z.boolean().default(false).describe('Only used when the other servers are unavailable.'),
+    down: z.boolean().default(false).describe('Take this server out of rotation (e.g. for maintenance).'),
+});
+export const updateLoadBalancer = defineTool({
+    name: 'forge_update_load_balancer',
+    title: 'Update load balancer nodes',
+    description: 'Replace the servers a load-balanced site sends traffic to, with the balancing method. Set `down: true` on a node to take it out of rotation. List every node that should stay.',
+    toolset: 'sites',
+    operations: ['organizations.servers.sites.load-balancing-nodes.update', 'organizations.servers.sites.load-balancing-nodes.index'],
+    permissions: ['site:manage-project'],
+    readOnly: false,
+    destructive: true,
+    idempotent: true,
+    async: true,
+    notFoundHint: 'Check the load balancer server and site IDs with forge_list_sites.',
+    inputSchema: {
+        ...siteScopeInput,
+        nodes: z.array(node).min(1).describe('Every server that should receive traffic (replaces the list).'),
+        method: z.enum(['round_robin', 'least_conn', 'ip_hash']).default('round_robin').describe('Balancing method; ip_hash keeps each client on the same server.'),
+        keepalive_max_connections: z.number().int().min(0).max(256).optional().describe('Idle keepalive connections kept open to each server.'),
+        ...waitInput(60),
+    },
+    outputSchema: {
+        ...operationOutput,
+        nodes: z.array(nodeOutput).nullable(),
+    },
+    async handler(args, { client, organization, signal, sleep, progress }) {
+        const path = nodesPath(organization(args.organization), args.server, args.site);
+        await client.put(path, {
+            body: { balancer_method: args.method, balancer_keepalive_max_connections: args.keepalive_max_connections, balancing: args.nodes },
+            signal,
+        });
+        const action = 'update the load balancer';
+        if (!args.wait) {
+            const accepted = queued(action, CHECK_WITH);
+            return { ...accepted, structured: { ...accepted.structured, nodes: null } };
+        }
+        const key = (n) => `${n.server_id}:${n.weight}:${n.backup}:${n.down}`;
+        const expected = args.nodes.map(key).sort().join();
+        const matches = (nodes) => nodes.map(key).sort().join() === expected;
+        const result = await waitFor({
+            poll: () => readNodes(client, path, signal),
+            phase: (nodes) => (matches(nodes) ? 'completed' : 'pending'),
+            describe: () => 'Waiting for the nodes to be updated',
+            timeoutSeconds: args.timeout_seconds,
+            context: { sleep, progress },
+        });
+        const done = outcome(result, { action, checkWith: CHECK_WITH, timeoutSeconds: args.timeout_seconds });
+        return { structured: { ...done.structured, nodes: result.value ?? null }, summary: done.summary };
+    },
+});

package/dist/tools/monitors/create-monitor.js

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+import { flattenSingle } from '../../forge/jsonapi.js';
+import { defineTool } from '../define-tool.js';
+import { operationOutput, outcome, waitFor, waitInput } from '../shared/async.js';
+import { readResource } from '../shared/read.js';
+import { organizationInput, serverInput } from '../shared/schemas.js';
+import { SERVER_NOT_FOUND_HINT } from '../servers/shared.js';
+import { formatMonitor, MONITOR_TYPES, monitorOutput, monitorPhase, monitorsPath } from './shared.js';
+const CHECK_WITH = 'forge_list_monitors';
+export const createMonitor = defineTool({
+    name: 'forge_create_monitor',
+    title: 'Create monitor',
+    description: 'Alert by email when a server metric crosses a threshold, e.g. disk ≥ 80 (%), used_memory ≥ 90 (%), cpu_load ≥ 4 for 5 minutes. Waits until the monitor is installed unless `wait` is false.',
+    toolset: 'monitoring',
+    operations: ['organizations.servers.monitors.store', 'organizations.servers.monitors.show'],
+    permissions: ['server:create-monitors', 'server:view'],
+    readOnly: false,
+    destructive: false,
+    idempotent: false,
+    async: true,
+    notFoundHint: SERVER_NOT_FOUND_HINT,
+    inputSchema: {
+        organization: organizationInput,
+        server: serverInput,
+        type: z.enum(MONITOR_TYPES).describe('Metric: cpu_load (load average), disk (% used), free_memory or used_memory (%).'),
+        operator: z.enum(['gte', 'lte']).default('gte').describe('gte: alert at or above the threshold; lte: at or below.'),
+        threshold: z.number().describe('Threshold, e.g. 80.'),
+        minutes: z.number().int().min(1).optional().describe('Minutes the condition must last before alerting.'),
+        notify: z.string().email().describe('Email to notify.'),
+        ...waitInput(60),
+    },
+    outputSchema: {
+        ...operationOutput,
+        monitor: monitorOutput.nullable(),
+    },
+    async handler(args, { client, organization, signal, sleep, progress }) {
+        const base = monitorsPath(organization(args.organization), args.server);
+        const response = await client.post(base, {
+            body: { type: args.type, operator: args.operator, threshold: args.threshold, minutes: args.minutes, notify: args.notify },
+            signal,
+        });
+        const initial = response.data?.data ? flattenSingle(response.data) : undefined;
+        const action = `monitor ${args.type} ${args.operator} ${args.threshold}`;
+        if (!initial || !args.wait) {
+            return {
+                structured: { status: 'queued', check_with: CHECK_WITH, monitor: initial ? formatMonitor(initial) : null },
+                summary: `Forge accepted the request to ${action}. Check it with ${CHECK_WITH}.`,
+            };
+        }
+        const result = await waitFor({
+            initial,
+            poll: () => readResource(client, `${base}/${encodeURIComponent(initial.id)}`, signal),
+            phase: (monitor) => monitorPhase(monitor.status),
+            describe: (monitor) => `Monitor is ${monitor.status}`,
+            timeoutSeconds: args.timeout_seconds,
+            context: { sleep, progress },
+        });
+        const monitor = formatMonitor(result.value ?? initial);
+        const done = outcome(result, { action, checkWith: CHECK_WITH, timeoutSeconds: args.timeout_seconds, detail: `Monitor ID: ${monitor.id}.` });
+        return { structured: { ...done.structured, monitor }, summary: done.summary };
+    },
+});

package/dist/tools/monitors/delete-monitor.js

@@ -0,0 +1,41 @@
+import { defineTool } from '../define-tool.js';
+import { operationOutput, orGone, outcome, queued, waitFor, waitInput } from '../shared/async.js';
+import { readResource } from '../shared/read.js';
+import { organizationInput, serverInput } from '../shared/schemas.js';
+import { monitorInput, monitorsPath } from './shared.js';
+const CHECK_WITH = 'forge_list_monitors';
+export const deleteMonitor = defineTool({
+    name: 'forge_delete_monitor',
+    title: 'Delete monitor',
+    description: 'Remove a monitor from a server: its alerts stop.',
+    toolset: 'monitoring',
+    operations: ['organizations.servers.monitors.destroy', 'organizations.servers.monitors.show'],
+    permissions: ['server:delete-monitors', 'server:view'],
+    readOnly: false,
+    destructive: true,
+    idempotent: true,
+    async: true,
+    notFoundHint: 'Check the monitor ID with forge_list_monitors.',
+    inputSchema: {
+        organization: organizationInput,
+        server: serverInput,
+        monitor: monitorInput,
+        ...waitInput(60),
+    },
+    outputSchema: operationOutput,
+    async handler(args, { client, organization, signal, sleep, progress }) {
+        const path = `${monitorsPath(organization(args.organization), args.server)}/${encodeURIComponent(String(args.monitor))}`;
+        await client.delete(path, { signal });
+        const action = `delete monitor ${args.monitor}`;
+        if (!args.wait)
+            return queued(action, CHECK_WITH);
+        const result = await waitFor({
+            poll: () => orGone(() => readResource(client, path, signal)),
+            phase: (monitor) => (monitor === null ? 'completed' : 'pending'),
+            describe: (monitor) => `Monitor is ${monitor?.status ?? 'removing'}`,
+            timeoutSeconds: args.timeout_seconds,
+            context: { sleep, progress },
+        });
+        return outcome(result, { action, checkWith: CHECK_WITH, timeoutSeconds: args.timeout_seconds });
+    },
+});

package/dist/tools/monitors/list-monitors.js

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+import { flattenCollection } from '../../forge/jsonapi.js';
+import { defineTool } from '../define-tool.js';
+import { readResource } from '../shared/read.js';
+import { organizationInput, paginationInput, paginationOutput, paginationSummary, serverInput } from '../shared/schemas.js';
+import { SERVER_NOT_FOUND_HINT } from '../servers/shared.js';
+import { formatMonitor, MONITOR_TYPES, monitorInput, monitorOutput, monitorsPath } from './shared.js';
+const SORT = ['state', '-state', 'status', '-status', 'created_at', '-created_at', 'updated_at', '-updated_at'];
+export const listMonitors = defineTool({
+    name: 'forge_list_monitors',
+    title: 'List monitors',
+    description: 'List the resource monitors of a server (CPU load, disk, memory thresholds) and whether they are in ALERT, or get one with `monitor`.',
+    toolset: 'monitoring',
+    operations: ['organizations.servers.monitors.index', 'organizations.servers.monitors.show'],
+    permissions: ['server:view'],
+    readOnly: true,
+    notFoundHint: SERVER_NOT_FOUND_HINT,
+    inputSchema: {
+        organization: organizationInput,
+        server: serverInput,
+        monitor: monitorInput.optional().describe('Return only this monitor.'),
+        state: z.enum(['OK', 'ALERT', 'UNKNOWN']).optional().describe('Filter by state.'),
+        type: z.enum(MONITOR_TYPES).optional().describe('Filter by metric.'),
+        status: z.string().min(1).optional().describe('Filter by installation status.'),
+        notify: z.string().min(1).optional().describe('Filter by notified email.'),
+        sort: z.array(z.enum(SORT)).min(1).optional(),
+        ...paginationInput,
+    },
+    outputSchema: {
+        monitors: z.array(monitorOutput),
+        ...paginationOutput,
+    },
+    async handler(args, { client, organization, signal }) {
+        const base = monitorsPath(organization(args.organization), args.server);
+        if (args.monitor !== undefined) {
+            const monitor = formatMonitor(await readResource(client, `${base}/${encodeURIComponent(String(args.monitor))}`, signal));
+            return { structured: { monitors: [monitor], next_cursor: null, has_more: false }, summary: `Monitor ${monitor.type} is ${monitor.state}.` };
+        }
+        const response = await client.get(base, {
+            query: {
+                filter: { state: args.state, type: args.type, status: args.status, notify: args.notify },
+                sort: args.sort,
+                page: { size: args.page_size, cursor: args.cursor },
+            },
+            signal,
+        });
+        const page = flattenCollection(response.data);
+        const monitors = page.items.map(formatMonitor);
+        const alerting = monitors.filter((monitor) => monitor.state === 'ALERT');
+        return {
+            structured: { monitors, next_cursor: page.nextCursor, has_more: page.nextCursor !== null },
+            summary: monitors.length === 0
+                ? 'No monitors found.'
+                : `Found ${monitors.length} monitor(s)${alerting.length > 0 ? `; in ALERT: ${alerting.map((m) => `${m.type} ${m.operator} ${m.threshold} (${m.id})`).join(', ')}` : ', none in alert'}.${paginationSummary(page.nextCursor)}`,
+        };
+    },
+});

package/dist/tools/monitors/shared.js

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { phaseOf } from '../shared/async.js';
+import { idInput, pick } from '../shared/schemas.js';
+import { serverPath } from '../servers/shared.js';
+export function monitorsPath(org, server) {
+    return `${serverPath(org, server)}/monitors`;
+}
+export const monitorInput = idInput('Monitor ID. Use forge_list_monitors to find it.');
+export const MONITOR_TYPES = ['cpu_load', 'disk', 'free_memory', 'used_memory'];
+const FIELDS = ['id', 'type', 'operator', 'threshold', 'minutes', 'notify', 'state', 'state_changed_at', 'status', 'created_at'];
+export const monitorOutput = z.looseObject({
+    id: z.string(),
+    type: z.string().nullable().describe('cpu_load, disk (% used), free_memory or used_memory (%).'),
+    operator: z.string().nullable().describe('gte (alert at or above the threshold) or lte (at or below).'),
+    threshold: z.number().nullable(),
+    minutes: z.number().nullable().describe('Minutes the condition must last before alerting.'),
+    notify: z.string().nullable().describe('Email notified on alerts.'),
+    state: z.string().nullable().describe('OK, ALERT or UNKNOWN.'),
+    state_changed_at: z.string().nullable(),
+    status: z.string().nullable().describe('Installation status, e.g. installing, installed.'),
+    created_at: z.string().nullable(),
+});
+export function formatMonitor(flat) {
+    return pick(flat, FIELDS);
+}
+export function monitorPhase(status) {
+    return phaseOf(status, { pending: ['installing', 'updating', 'enabling', 'syncing', 'removing'], failed: ['failed', 'failed-unknown', 'failed-runner'] });
+}

package/dist/tools/nginx-templates/create-nginx-template.js

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+import { flattenSingle } from '../../forge/jsonapi.js';
+import { defineTool } from '../define-tool.js';
+import { organizationInput, serverInput } from '../shared/schemas.js';
+import { SERVER_NOT_FOUND_HINT } from '../servers/shared.js';
+import { formatNginxTemplate, nginxTemplateContentInput, nginxTemplateOutput, nginxTemplatesPath } from './shared.js';
+export const createNginxTemplate = defineTool({
+    name: 'forge_create_nginx_template',
+    title: 'Create Nginx template',
+    description: 'Save a custom Nginx template on a server, to use when creating sites (`nginx_template_id` in forge_create_site).',
+    toolset: 'servers',
+    operations: ['organizations.servers.nginx.templates.store'],
+    permissions: ['server:manage-nginx-templates'],
+    readOnly: false,
+    destructive: false,
+    idempotent: false,
+    notFoundHint: SERVER_NOT_FOUND_HINT,
+    inputSchema: {
+        organization: organizationInput,
+        server: serverInput,
+        name: z.string().min(1).describe('Template name.'),
+        content: nginxTemplateContentInput,
+    },
+    outputSchema: {
+        template: nginxTemplateOutput,
+    },
+    async handler(args, { client, organization, signal }) {
+        const response = await client.post(nginxTemplatesPath(organization(args.organization), args.server), {
+            body: { name: args.name, content: args.content },
+            signal,
+        });
+        const template = formatNginxTemplate(flattenSingle(response.data), false);
+        return { structured: { template }, summary: `Created Nginx template ${template.name} (ID ${template.id}).` };
+    },
+});

package/dist/tools/nginx-templates/delete-nginx-template.js

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { defineTool } from '../define-tool.js';
+import { organizationInput, serverInput } from '../shared/schemas.js';
+import { NGINX_TEMPLATE_NOT_FOUND_HINT, nginxTemplateInput, nginxTemplatePath } from './shared.js';
+export const deleteNginxTemplate = defineTool({
+    name: 'forge_delete_nginx_template',
+    title: 'Delete Nginx template',
+    description: 'Delete an Nginx template. Sites created from it keep their configuration.',
+    toolset: 'servers',
+    operations: ['organizations.servers.nginx.templates.destroy'],
+    permissions: ['server:manage-nginx-templates'],
+    readOnly: false,
+    destructive: true,
+    idempotent: true,
+    notFoundHint: NGINX_TEMPLATE_NOT_FOUND_HINT,
+    inputSchema: {
+        organization: organizationInput,
+        server: serverInput,
+        template: nginxTemplateInput,
+    },
+    outputSchema: {
+        deleted: z.boolean(),
+    },
+    async handler(args, { client, organization, signal }) {
+        await client.delete(nginxTemplatePath(organization(args.organization), args.server, args.template), { signal });
+        return { structured: { deleted: true }, summary: `Deleted Nginx template ${args.template}.` };
+    },
+});

package/dist/tools/nginx-templates/list-nginx-templates.js

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+import { flattenCollection } from '../../forge/jsonapi.js';
+import { defineTool } from '../define-tool.js';
+import { readResource } from '../shared/read.js';
+import { organizationInput, paginationInput, paginationOutput, paginationSummary, responseFormatInput, serverInput } from '../shared/schemas.js';
+import { SERVER_NOT_FOUND_HINT } from '../servers/shared.js';
+import { formatNginxTemplate, nginxTemplateInput, nginxTemplateOutput, nginxTemplatePath, nginxTemplatesPath } from './shared.js';
+const SORT = ['name', '-name', 'created_at', '-created_at', 'updated_at', '-updated_at'];
+export const listNginxTemplates = defineTool({
+    name: 'forge_list_nginx_templates',
+    title: 'List Nginx templates',
+    description: 'List the Nginx templates of a server (custom server blocks used when creating sites, see `nginx_template_id` in forge_create_site), or read one with its content using `template`.',
+    toolset: 'servers',
+    operations: ['organizations.servers.nginx.templates.index', 'organizations.servers.nginx.templates.show'],
+    permissions: ['server:view'],
+    readOnly: true,
+    notFoundHint: SERVER_NOT_FOUND_HINT,
+    inputSchema: {
+        organization: organizationInput,
+        server: serverInput,
+        template: nginxTemplateInput.optional().describe('Return only this template, with its content.'),
+        name: z.string().min(1).optional().describe('Filter by name.'),
+        sort: z.array(z.enum(SORT)).min(1).optional(),
+        response_format: responseFormatInput.describe('"detailed" also returns the content of every template.'),
+        ...paginationInput,
+    },
+    outputSchema: {
+        templates: z.array(nginxTemplateOutput),
+        ...paginationOutput,
+    },
+    async handler(args, { client, organization, signal }) {
+        const org = organization(args.organization);
+        if (args.template !== undefined) {
+            const template = formatNginxTemplate(await readResource(client, nginxTemplatePath(org, args.server, args.template), signal), true);
+            return { structured: { templates: [template], next_cursor: null, has_more: false }, summary: `Nginx template ${template.name}.` };
+        }
+        const response = await client.get(nginxTemplatesPath(org, args.server), {
+            query: { filter: { name: args.name }, sort: args.sort, page: { size: args.page_size, cursor: args.cursor } },
+            signal,
+        });
+        const page = flattenCollection(response.data);
+        const templates = page.items.map((item) => formatNginxTemplate(item, args.response_format === 'detailed'));
+        return {
+            structured: { templates, next_cursor: page.nextCursor, has_more: page.nextCursor !== null },
+            summary: templates.length === 0
+                ? 'No Nginx templates found.'
+                : `Found ${templates.length} Nginx template(s): ${templates.map((t) => `${t.name} (${t.id})`).join(', ')}.${paginationSummary(page.nextCursor)}`,
+        };
+    },
+});

package/dist/tools/nginx-templates/shared.js

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import { idInput, pick } from '../shared/schemas.js';
+import { serverPath } from '../servers/shared.js';
+export function nginxTemplatesPath(org, server) {
+    return `${serverPath(org, server)}/nginx/templates`;
+}
+export function nginxTemplatePath(org, server, template) {
+    return `${nginxTemplatesPath(org, server)}/${encodeURIComponent(String(template))}`;
+}
+export const nginxTemplateInput = idInput('Nginx template ID. Use forge_list_nginx_templates to find it.');
+export const NGINX_TEMPLATE_NOT_FOUND_HINT = 'Check the template ID with forge_list_nginx_templates.';
+export const nginxTemplateContentInput = z
+    .string()
+    .min(1)
+    .describe('Nginx server block; Forge replaces variables such as {{DOMAINS}}, {{PATH}}, {{PORT}} and {{PROXY_PASS}} when it creates a site.');
+export const nginxTemplateOutput = z.looseObject({
+    id: z.string(),
+    name: z.string().nullable(),
+    content: z.string().nullable().optional().describe('Template content (only when reading one template or with response_format "detailed").'),
+    created_at: z.string().nullable(),
+    updated_at: z.string().nullable(),
+});
+export function formatNginxTemplate(flat, withContent) {
+    return pick(flat, withContent ? ['id', 'name', 'content', 'created_at', 'updated_at'] : ['id', 'name', 'created_at', 'updated_at']);
+}

package/dist/tools/nginx-templates/update-nginx-template.js

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+import { flattenSingle } from '../../forge/jsonapi.js';
+import { defineTool } from '../define-tool.js';
+import { ToolInputError } from '../errors.js';
+import { readResource } from '../shared/read.js';
+import { organizationInput, serverInput } from '../shared/schemas.js';
+import { formatNginxTemplate, NGINX_TEMPLATE_NOT_FOUND_HINT, nginxTemplateContentInput, nginxTemplateInput, nginxTemplateOutput, nginxTemplatePath } from './shared.js';
+export const updateNginxTemplate = defineTool({
+    name: 'forge_update_nginx_template',
+    title: 'Update Nginx template',
+    description: 'Rename an Nginx template or replace its content. Existing sites are not changed: the template is used for new sites only.',
+    toolset: 'servers',
+    operations: ['organizations.servers.nginx.templates.update', 'organizations.servers.nginx.templates.show'],
+    permissions: ['server:manage-nginx-templates', 'server:view'],
+    readOnly: false,
+    destructive: false,
+    idempotent: true,
+    notFoundHint: NGINX_TEMPLATE_NOT_FOUND_HINT,
+    inputSchema: {
+        organization: organizationInput,
+        server: serverInput,
+        template: nginxTemplateInput,
+        name: z.string().min(1).optional().describe('New name.'),
+        content: nginxTemplateContentInput.optional().describe('New content (replaces the whole template).'),
+    },
+    outputSchema: {
+        template: nginxTemplateOutput,
+    },
+    async handler(args, { client, organization, signal }) {
+        if (args.name === undefined && args.content === undefined)
+            throw new ToolInputError('Pass `name` and/or `content`.');
+        const path = nginxTemplatePath(organization(args.organization), args.server, args.template);
+        // Both fields are required by the API: keep the current value of the one not changed.
+        const current = args.name === undefined || args.content === undefined ? await readResource(client, path, signal) : undefined;
+        const response = await client.put(path, {
+            body: { name: args.name ?? current?.name, content: args.content ?? current?.content },
+            signal,
+        });
+        const template = formatNginxTemplate(flattenSingle(response.data), false);
+        return { structured: { template }, summary: `Updated Nginx template ${template.name}.` };
+    },
+});

package/dist/tools/package-credentials/delete-package-credentials.js

@@ -0,0 +1,41 @@
+import { defineTool } from '../define-tool.js';
+import { operationOutput, orGone, outcome, queued, waitFor, waitInput } from '../shared/async.js';
+import { readResource } from '../shared/read.js';
+import { siteScopeInput } from '../shared/site-scope.js';
+import { credentialKeyInput, credentialOperations, credentialPath, managerInput } from './shared.js';
+const CHECK_WITH = 'forge_list_package_credentials';
+export const deletePackageCredentials = defineTool({
+    name: 'forge_delete_package_credentials',
+    title: 'Delete package credentials',
+    description: 'Remove the credentials of a private Composer repository or npm registry: installing its packages will fail.',
+    toolset: 'sites',
+    operations: [...credentialOperations('destroy'), ...credentialOperations('show')],
+    permissions: ['server:manage-packages', 'server:view'],
+    readOnly: false,
+    destructive: true,
+    idempotent: true,
+    async: true,
+    notFoundHint: 'Check the repository with forge_list_package_credentials.',
+    inputSchema: {
+        ...siteScopeInput,
+        manager: managerInput,
+        repository: credentialKeyInput,
+        ...waitInput(60),
+    },
+    outputSchema: operationOutput,
+    async handler(args, { client, organization, signal, sleep, progress }) {
+        const path = credentialPath(organization(args.organization), args.server, args.site, args.manager, args.repository);
+        await client.delete(path, { signal });
+        const action = `delete the ${args.manager} credentials for ${args.repository}`;
+        if (!args.wait)
+            return queued(action, CHECK_WITH);
+        const result = await waitFor({
+            poll: () => orGone(() => readResource(client, path, signal)),
+            phase: (credential) => (credential === null ? 'completed' : 'pending'),
+            describe: () => 'Waiting for the credentials to be removed',
+            timeoutSeconds: args.timeout_seconds,
+            context: { sleep, progress },
+        });
+        return outcome(result, { action, checkWith: CHECK_WITH, timeoutSeconds: args.timeout_seconds });
+    },
+});

package/dist/tools/package-credentials/list-package-credentials.js

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+import { flattenCollection } from '../../forge/jsonapi.js';
+import { defineTool } from '../define-tool.js';
+import { readResource } from '../shared/read.js';
+import { paginationInput, paginationOutput, paginationSummary } from '../shared/schemas.js';
+import { SITE_NOT_FOUND_HINT, siteScopeInput } from '../shared/site-scope.js';
+import { credentialKeyInput, credentialOperations, credentialOutput, credentialPath, credentialsPath, formatCredential, managerInput, } from './shared.js';
+export const listPackageCredentials = defineTool({
+    name: 'forge_list_package_credentials',
+    title: 'List package credentials',
+    description: 'List the credentials a site uses to install private Composer or npm packages (auth.json / .npmrc), or get one with `repository`. Passwords and tokens are hidden unless secrets are allowed.',
+    toolset: 'sites',
+    operations: [...credentialOperations('index'), ...credentialOperations('show')],
+    permissions: ['server:view'],
+    readOnly: true,
+    notFoundHint: SITE_NOT_FOUND_HINT,
+    inputSchema: {
+        ...siteScopeInput,
+        manager: managerInput,
+        repository: credentialKeyInput.optional().describe('Return only the credentials of this repository or registry.'),
+        ...paginationInput,
+    },
+    outputSchema: {
+        credentials: z.array(credentialOutput),
+        ...paginationOutput,
+    },
+    async handler(args, { client, config, organization, signal }) {
+        const org = organization(args.organization);
+        const format = (flat) => formatCredential(args.manager, flat, config.allowSecrets);
+        if (args.repository !== undefined) {
+            const credential = format(await readResource(client, credentialPath(org, args.server, args.site, args.manager, args.repository), signal));
+            return { structured: { credentials: [credential], next_cursor: null, has_more: false }, summary: `Credentials for ${credential.repository}.` };
+        }
+        const response = await client.get(credentialsPath(org, args.server, args.site, args.manager), {
+            query: { page: { size: args.page_size, cursor: args.cursor } },
+            signal,
+        });
+        const page = flattenCollection(response.data);
+        const credentials = page.items.map(format);
+        return {
+            structured: { credentials, next_cursor: page.nextCursor, has_more: page.nextCursor !== null },
+            summary: credentials.length === 0
+                ? `No ${args.manager} credentials found.`
+                : `Found ${args.manager} credentials for: ${credentials.map((c) => c.repository).join(', ')}.${paginationSummary(page.nextCursor)}`,
+        };
+    },
+});

package/dist/tools/package-credentials/set-package-credentials.js

@@ -0,0 +1,73 @@
+import { z } from 'zod';
+import { defineTool } from '../define-tool.js';
+import { ToolInputError } from '../errors.js';
+import { operationOutput, orGone, outcome, queued, waitFor, waitInput } from '../shared/async.js';
+import { readResource } from '../shared/read.js';
+import { SITE_NOT_FOUND_HINT, siteScopeInput } from '../shared/site-scope.js';
+import { credentialKeyInput, credentialOperations, credentialPath, credentialsPath, managerInput } from './shared.js';
+const CHECK_WITH = 'forge_list_package_credentials';
+export const setPackageCredentials = defineTool({
+    name: 'forge_set_package_credentials',
+    title: 'Set package credentials',
+    description: 'Add or replace the credentials a site uses for a private Composer repository (`username` + `password`, e.g. Laravel Nova or Spark) or npm registry (`token`, optional `scopes`). Secrets are never returned.',
+    toolset: 'sites',
+    operations: [...credentialOperations('store'), ...credentialOperations('update'), ...credentialOperations('show')],
+    permissions: ['server:manage-packages', 'server:view'],
+    readOnly: false,
+    destructive: false,
+    idempotent: true,
+    async: true,
+    notFoundHint: SITE_NOT_FOUND_HINT,
+    inputSchema: {
+        ...siteScopeInput,
+        manager: managerInput,
+        repository: credentialKeyInput,
+        username: z.string().min(1).optional().describe('Composer only.'),
+        password: z.string().min(1).optional().describe('Composer only (never returned).'),
+        token: z.string().min(1).optional().describe('npm only (never returned).'),
+        scopes: z.array(z.string().min(1)).optional().describe('npm only: scopes served by the registry, e.g. ["@acme"].'),
+        ...waitInput(60),
+    },
+    outputSchema: {
+        ...operationOutput,
+        created: z.boolean().describe('Whether the credentials were added (false: replaced).'),
+    },
+    async handler(args, { client, organization, signal, sleep, progress }) {
+        const composer = args.manager === 'composer';
+        if (composer && (!args.username || !args.password || args.token || args.scopes)) {
+            throw new ToolInputError('Composer credentials need `username` and `password` (no `token` or `scopes`).');
+        }
+        if (!composer && (!args.token || args.username || args.password)) {
+            throw new ToolInputError('npm credentials need `token` and optionally `scopes` (no `username` or `password`).');
+        }
+        const org = organization(args.organization);
+        const path = credentialPath(org, args.server, args.site, args.manager, args.repository);
+        const body = composer
+            ? { repository: args.repository, username: args.username, password: args.password }
+            : { registry: args.repository, token: args.token, scopes: args.scopes };
+        const exists = (await orGone(() => readResource(client, path, signal))) !== null;
+        if (exists)
+            await client.put(path, { body, signal });
+        else
+            await client.post(credentialsPath(org, args.server, args.site, args.manager), { body, signal });
+        const action = `${exists ? 'replace' : 'add'} the ${args.manager} credentials for ${args.repository}`;
+        if (!args.wait) {
+            const accepted = queued(action, CHECK_WITH);
+            return { ...accepted, structured: { ...accepted.structured, created: !exists } };
+        }
+        // Compared here without ever returning the secret.
+        const matches = (current) => current !== null &&
+            (composer
+                ? current.username === args.username && current.password === args.password
+                : current.token === args.token && (args.scopes === undefined || JSON.stringify(current.scopes ?? []) === JSON.stringify(args.scopes)));
+        const result = await waitFor({
+            poll: () => orGone(() => readResource(client, path, signal)),
+            phase: (current) => (matches(current) ? 'completed' : 'pending'),
+            describe: () => `Waiting for the ${args.manager} credentials to be saved`,
+            timeoutSeconds: args.timeout_seconds,
+            context: { sleep, progress },
+        });
+        const done = outcome(result, { action, checkWith: CHECK_WITH, timeoutSeconds: args.timeout_seconds });
+        return { structured: { ...done.structured, created: !exists }, summary: done.summary };
+    },
+});

package/dist/tools/package-credentials/shared.js

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import { redact } from '../shared/secrets.js';
+import { sitePath } from '../shared/site-scope.js';
+export const MANAGERS = ['composer', 'npm'];
+export const managerInput = z.enum(MANAGERS).describe('composer (private Composer repositories) or npm (private npm registries).');
+export const credentialKeyInput = z
+    .string()
+    .min(1)
+    .describe('Composer repository host (e.g. "repo.packagist.com") or npm registry (e.g. "npm.pkg.github.com").');
+export function credentialsPath(org, server, site, manager) {
+    return `${sitePath(org, server, site)}/${manager}/credentials`;
+}
+export function credentialPath(org, server, site, manager, key) {
+    return `${credentialsPath(org, server, site, manager)}/${encodeURIComponent(key)}`;
+}
+export function credentialOperations(verb) {
+    return MANAGERS.map((manager) => `organizations.servers.sites.${manager}.credentials.${verb}`);
+}
+export const credentialOutput = z.looseObject({
+    manager: z.enum(MANAGERS),
+    repository: z.string().nullable().describe('Composer repository or npm registry.'),
+    username: z.string().nullable().describe('Composer only.'),
+    scopes: z.array(z.string()).nullable().describe('npm only: package scopes served by the registry.'),
+    secret: z.string().nullable().describe('Password (Composer) or token (npm), hidden unless secrets are allowed.'),
+});
+export function formatCredential(manager, flat, allowSecrets) {
+    const composer = manager === 'composer';
+    const secret = (composer ? flat.password : flat.token);
+    return redact({
+        manager,
+        repository: (composer ? flat.repository : flat.registry) ?? null,
+        username: composer ? (flat.username ?? null) : null,
+        scopes: composer ? null : (flat.scopes ?? null),
+        secret: secret ?? null,
+    }, ['secret'], allowSecrets);
+}

package/dist/tools/registry.js

@@ -60,7 +60,23 @@ import { listFirewallRules } from './firewall/list-firewall-rules.js';
 import { disableSiteIntegration } from './integrations/disable-site-integration.js';
 import { enableSiteIntegration } from './integrations/enable-site-integration.js';
 import { getSiteIntegrations } from './integrations/get-site-integrations.js';
+import { createHeartbeat } from './heartbeats/create-heartbeat.js';
+import { deleteHeartbeat } from './heartbeats/delete-heartbeat.js';
+import { listHeartbeats } from './heartbeats/list-heartbeats.js';
+import { updateHeartbeat } from './heartbeats/update-heartbeat.js';
+import { getLoadBalancer } from './load-balancing/get-load-balancer.js';
+import { updateLoadBalancer } from './load-balancing/update-load-balancer.js';
+import { createMonitor } from './monitors/create-monitor.js';
+import { deleteMonitor } from './monitors/delete-monitor.js';
+import { listMonitors } from './monitors/list-monitors.js';
+import { createNginxTemplate } from './nginx-templates/create-nginx-template.js';
+import { deleteNginxTemplate } from './nginx-templates/delete-nginx-template.js';
+import { listNginxTemplates } from './nginx-templates/list-nginx-templates.js';
+import { updateNginxTemplate } from './nginx-templates/update-nginx-template.js';
 import { listOrganizations } from './organizations/list-organizations.js';
+import { deletePackageCredentials } from './package-credentials/delete-package-credentials.js';
+import { listPackageCredentials } from './package-credentials/list-package-credentials.js';
+import { setPackageCredentials } from './package-credentials/set-package-credentials.js';
 import { getPhpConfig } from './php/get-php-config.js';
 import { getPhpSettings } from './php/get-php-settings.js';
 import { installPhpVersion } from './php/install-php-version.js';
@@ -160,6 +176,12 @@ export const ALL_TOOLS = [
     createCertificate,
     runCertificateAction,
     deleteCertificate,
+    // sites: packages and load balancing
+    listPackageCredentials,
+    setPackageCredentials,
+    deletePackageCredentials,
+    getLoadBalancer,
+    updateLoadBalancer,
     // servers
     runServiceAction,
     runServerAction,
@@ -168,6 +190,10 @@ export const ALL_TOOLS = [
     updateServer,
     getServerNetwork,
     updateServerNetwork,
+    listNginxTemplates,
+    createNginxTemplate,
+    updateNginxTemplate,
+    deleteNginxTemplate,
     listArchivedServers,
     archiveServer,
     unarchiveServer,
@@ -254,6 +280,14 @@ export const ALL_TOOLS = [
     deleteSshKey,
     getServerPublicKey,
     regenerateServerKey,
+    // monitoring
+    listHeartbeats,
+    createHeartbeat,
+    updateHeartbeat,
+    deleteHeartbeat,
+    listMonitors,
+    createMonitor,
+    deleteMonitor,
     // integrations
     getSiteIntegrations,
     enableSiteIntegration,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@francescomalatesta/laravel-forge-mcp",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "Unofficial Model Context Protocol (MCP) server for the Laravel Forge API",
   "keywords": [
     "mcp",