@francescomalatesta/laravel-forge-mcp 0.3.0 → 0.4.0

package/README.md

@@ -81,6 +81,20 @@ npm run build
 | `forge_get_site` | core | Every detail of a site, including its server |
 | `forge_list_server_events` | core | Operations Forge ran on a server or across the organization |
 | `forge_get_server_event` | core | An event with the output of its script |
+| `forge_create_site` | sites | Create a site (optionally with repository and database) and wait until it is installed |
+| `forge_create_balanced_site` | sites | Create a site on a load balancer |
+| `forge_update_site` | sites | Change PHP version, type, directories, branch, push to deploy, release retention |
+| `forge_update_site_repository` | sites | Switch source control provider, repository or branch |
+| `forge_delete_site` | sites | Delete a site |
+| `forge_set_site_env_vars` | sites | Set or remove .env variables without exposing the file |
+| `forge_get_site_environment` 🔑 | sites | Read the whole .env file |
+| `forge_update_site_environment` 🔑 | sites | Replace the whole .env file |
+| `forge_get_site_nginx_config` | sites | Read the site's Nginx configuration |
+| `forge_update_site_nginx_config` | sites | Replace the site's Nginx configuration |
+| `forge_get_site_log` | sites | End of the application, Nginx access or Nginx error log |
+| `forge_clear_site_log` | sites | Empty a site log |
+| `forge_get_site_healthcheck` | sites | Healthcheck URL used after zero-downtime deployments |
+| `forge_update_site_healthcheck` | sites | Set or remove the healthcheck URL |
 | `forge_list_deployments` | deployments | Deployments of a site or of every site on a server |
 | `forge_get_deployment` | deployments | A deployment with the end of its log |
 | `forge_get_deployment_status` | deployments | Whether a deployment is running |
@@ -98,7 +112,7 @@ npm run build
 | `forge_get_deploy_hook` 🔑 | deployments | The deployment trigger URL |
 | `forge_regenerate_deploy_hook` 🔑 | deployments | Generate a new deployment trigger URL |
 
-🔑 Returns secrets: registered only when `FORGE_ALLOW_SECRETS=true`. Secret fields returned by other tools (e.g. a site's `deployment_url`) are hidden unless secrets are allowed.
+🔑 Reads or replaces secrets: registered only when `FORGE_ALLOW_SECRETS=true`. Secret fields returned by other tools (e.g. a site's `deployment_url`) are hidden unless secrets are allowed.
 
 ### Background operations
 

package/dist/tools/deployments/shared.js

@@ -1,20 +1,10 @@
 import { z } from 'zod';
 import { ForgeApiError } from '../../forge/errors.js';
 import { flattenSingle } from '../../forge/jsonapi.js';
-import { apiPath } from '../../forge/path.js';
 import { phaseOf } from '../shared/async.js';
 import { relatedField, relatedId } from '../shared/relationships.js';
-import { organizationInput, serverInput, siteInput, tail } from '../shared/schemas.js';
-/** Arguments identifying a site: deployment endpoints are nested under the server. */
-export const siteScopeInput = {
-    organization: organizationInput,
-    server: serverInput,
-    site: siteInput,
-};
-export function sitePath(org, server, site) {
-    return apiPath `/orgs/${org}/servers/${server}/sites/${site}`;
-}
-export const SITE_NOT_FOUND_HINT = 'Check the server and site IDs with forge_list_sites (each site lists its `server_id`).';
+import { tail } from '../shared/schemas.js';
+export { SITE_NOT_FOUND_HINT, siteScopeInput, sitePath } from '../shared/site-scope.js';
 /** Deployments complete when finished and fail when failed, failed in the build or cancelled. */
 export function deploymentPhase(status) {
     return phaseOf(status, { completed: ['finished'], failed: ['failed', 'failed-build', 'cancelled'] });

package/dist/tools/registry.js

@@ -19,8 +19,22 @@ import { listServerEvents } from './events/list-server-events.js';
 import { listOrganizations } from './organizations/list-organizations.js';
 import { getServer } from './servers/get-server.js';
 import { listServers } from './servers/list-servers.js';
+import { clearSiteLog } from './sites/clear-site-log.js';
+import { createBalancedSite } from './sites/create-balanced-site.js';
+import { createSite } from './sites/create-site.js';
+import { deleteSite } from './sites/delete-site.js';
+import { getSiteEnvironment } from './sites/get-site-environment.js';
+import { getSiteHealthcheck } from './sites/get-site-healthcheck.js';
+import { getSiteLog } from './sites/get-site-log.js';
+import { getSiteNginxConfig } from './sites/get-site-nginx-config.js';
 import { getSite } from './sites/get-site.js';
 import { listSites } from './sites/list-sites.js';
+import { setSiteEnvVars } from './sites/set-site-env-vars.js';
+import { updateSite } from './sites/update-site.js';
+import { updateSiteEnvironment } from './sites/update-site-environment.js';
+import { updateSiteHealthcheck } from './sites/update-site-healthcheck.js';
+import { updateSiteNginxConfig } from './sites/update-site-nginx-config.js';
+import { updateSiteRepository } from './sites/update-site-repository.js';
 /** Every tool shipped by the server. Add new tools here. */
 export const ALL_TOOLS = [
     // core
@@ -31,6 +45,21 @@ export const ALL_TOOLS = [
     getSite,
     listServerEvents,
     getServerEvent,
+    // sites
+    createSite,
+    createBalancedSite,
+    updateSite,
+    updateSiteRepository,
+    deleteSite,
+    setSiteEnvVars,
+    getSiteEnvironment,
+    updateSiteEnvironment,
+    getSiteNginxConfig,
+    updateSiteNginxConfig,
+    getSiteLog,
+    clearSiteLog,
+    getSiteHealthcheck,
+    updateSiteHealthcheck,
     // deployments
     listDeployments,
     getDeployment,

package/dist/tools/shared/site-scope.js

@@ -0,0 +1,12 @@
+import { apiPath } from '../../forge/path.js';
+import { organizationInput, serverInput, siteInput } from './schemas.js';
+/** Arguments identifying a site: site endpoints are nested under the server. */
+export const siteScopeInput = {
+    organization: organizationInput,
+    server: serverInput,
+    site: siteInput,
+};
+export function sitePath(org, server, site) {
+    return apiPath `/orgs/${org}/servers/${server}/sites/${site}`;
+}
+export const SITE_NOT_FOUND_HINT = 'Check the server and site IDs with forge_list_sites (each site lists its `server_id`).';

package/dist/tools/sites/clear-site-log.js

@@ -0,0 +1,50 @@
+import { flattenSingle } from '../../forge/jsonapi.js';
+import { defineTool } from '../define-tool.js';
+import { operationOutput, outcome, queued, waitFor, waitInput } from '../shared/async.js';
+import { SITE_NOT_FOUND_HINT, siteScopeInput, sitePath } from '../shared/site-scope.js';
+import { siteLogInput } from './logs.js';
+const CHECK_WITH = 'forge_get_site_log';
+export const clearSiteLog = defineTool({
+    name: 'forge_clear_site_log',
+    title: 'Clear site log',
+    description: 'Empty a site log (application, Nginx access or Nginx error). The previous content is lost.',
+    toolset: 'sites',
+    operations: [
+        'organizations.servers.sites.logs.application.destroy',
+        'organizations.servers.sites.logs.nginx-access.destroy',
+        'organizations.servers.sites.logs.nginx-error.destroy',
+        'organizations.servers.sites.logs.application.show',
+        'organizations.servers.sites.logs.nginx-access.show',
+        'organizations.servers.sites.logs.nginx-error.show',
+    ],
+    permissions: ['server:manage-logs'],
+    readOnly: false,
+    destructive: true,
+    idempotent: true,
+    async: true,
+    notFoundHint: SITE_NOT_FOUND_HINT,
+    inputSchema: {
+        ...siteScopeInput,
+        log: siteLogInput,
+        ...waitInput(60),
+    },
+    outputSchema: operationOutput,
+    async handler(args, { client, organization, signal, sleep, progress }) {
+        const path = `${sitePath(organization(args.organization), args.server, args.site)}/logs/${args.log}`;
+        await client.delete(path, { signal });
+        const action = `clear the ${args.log} log`;
+        if (!args.wait)
+            return queued(action, CHECK_WITH);
+        const result = await waitFor({
+            poll: async () => {
+                const response = await client.get(path, { signal });
+                return (flattenSingle(response.data).content ?? '').trim();
+            },
+            phase: (content) => (content === '' ? 'completed' : 'pending'),
+            describe: () => `Waiting for the ${args.log} log to be cleared`,
+            timeoutSeconds: args.timeout_seconds,
+            context: { sleep, progress },
+        });
+        return outcome(result, { action, checkWith: CHECK_WITH, timeoutSeconds: args.timeout_seconds });
+    },
+});

package/dist/tools/sites/create-balanced-site.js

@@ -0,0 +1,70 @@
+import { z } from 'zod';
+import { flattenSingle } from '../../forge/jsonapi.js';
+import { apiPath } from '../../forge/path.js';
+import { defineTool } from '../define-tool.js';
+import { operationOutput, outcome, waitFor, waitInput } from '../shared/async.js';
+import { organizationInput, serverInput } from '../shared/schemas.js';
+import { formatSite, siteOutput } from './format.js';
+import { readSite, sitePhase } from './shared.js';
+const CHECK_WITH = 'forge_get_site';
+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).optional().describe('Relative share of traffic.'),
+    backup: z.boolean().optional().describe('Only used when the other servers are unavailable.'),
+    down: z.boolean().optional().describe('Temporarily take this server out of rotation.'),
+});
+export const createBalancedSite = defineTool({
+    name: 'forge_create_balanced_site',
+    title: 'Create load-balanced site',
+    description: 'Create a site on a load balancer server that distributes traffic to sites on other servers. Waits until Forge finishes installing it unless `wait` is false.',
+    toolset: 'sites',
+    operations: ['organizations.servers.sites.storeOnBalancer', 'organizations.sites.show'],
+    permissions: ['site:create', 'server:view'],
+    readOnly: false,
+    destructive: false,
+    idempotent: false,
+    async: true,
+    notFoundHint: 'Check the load balancer server ID with forge_list_servers (type "loadbalancer").',
+    inputSchema: {
+        organization: organizationInput,
+        server: serverInput.describe('ID of the load balancer server.'),
+        domain: z.string().min(1).describe('Domain of the site, e.g. "example.com".'),
+        balancing: z.array(node).min(1).describe('Servers that receive the traffic.'),
+        balancer_method: z.enum(['round_robin', 'least_conn', 'ip_hash']).optional(),
+        balancer_keepalive_max_connections: z.number().int().optional(),
+        allow_wildcard_subdomains: z.boolean().optional(),
+        ...waitInput(300),
+    },
+    outputSchema: {
+        ...operationOutput,
+        site: siteOutput.nullable(),
+    },
+    async handler(args, { client, config, organization, signal, sleep, progress }) {
+        const org = organization(args.organization);
+        const { organization: _org, server, wait, timeout_seconds, ...body } = args;
+        const created = await client.post(apiPath `/orgs/${org}/servers/${server}/sites/balancer`, {
+            body,
+            signal,
+        });
+        const initial = created.data?.data ? flattenSingle(created.data) : undefined;
+        const format = (flat) => formatSite(flat, { detailed: false, allowSecrets: config.allowSecrets, serverId: String(server) });
+        const action = `create the load-balanced site "${args.domain}"`;
+        if (!initial || !wait) {
+            return {
+                structured: { status: 'queued', check_with: initial ? CHECK_WITH : 'forge_list_sites', site: initial ? format(initial) : null },
+                summary: `Forge accepted the request to ${action}. Follow it with ${initial ? `${CHECK_WITH} (site ${initial.id})` : 'forge_list_sites'}.`,
+            };
+        }
+        const result = await waitFor({
+            initial,
+            poll: () => readSite(client, org, initial.id, signal),
+            phase: (site) => sitePhase(site.status),
+            describe: (site) => `Site ${site.id} is ${site.status}`,
+            timeoutSeconds: timeout_seconds,
+            context: { sleep, progress },
+        });
+        const done = outcome(result, { action, checkWith: CHECK_WITH, timeoutSeconds: timeout_seconds });
+        return { structured: { ...done.structured, site: format(result.value ?? initial) }, summary: done.summary };
+    },
+});

package/dist/tools/sites/create-site.js

@@ -0,0 +1,113 @@
+import { z } from 'zod';
+import { flattenSingle } from '../../forge/jsonapi.js';
+import { apiPath } from '../../forge/path.js';
+import { defineTool } from '../define-tool.js';
+import { operationOutput, outcome, waitFor, waitInput } from '../shared/async.js';
+import { organizationInput, serverInput } from '../shared/schemas.js';
+import { formatSite, siteOutput } from './format.js';
+import { PHP_VERSIONS, SITE_TYPES, SOURCE_CONTROL_PROVIDERS, readSite, sitePhase } from './shared.js';
+const CHECK_WITH = 'forge_get_site';
+const sharedPath = z.object({
+    from: z.string().min(1).describe("Path relative to the project's root directory on the server."),
+    to: z.string().min(1).describe("Path relative to the release directory to link it to."),
+});
+export const createSite = defineTool({
+    name: 'forge_create_site',
+    title: 'Create site',
+    description: 'Create a site (virtual host) on a server, optionally installing a Git repository and connecting a database. Waits until Forge finishes installing it unless `wait` is false. Find database and source-control IDs with the related list tools; deploy it afterwards with forge_deploy_site.',
+    toolset: 'sites',
+    operations: ['organizations.servers.sites.store', 'organizations.sites.show'],
+    permissions: ['site:create', 'server:view'],
+    readOnly: false,
+    destructive: false,
+    idempotent: false,
+    async: true,
+    notFoundHint: 'Check the server ID with forge_list_servers.',
+    inputSchema: {
+        organization: organizationInput,
+        server: serverInput,
+        name: z.string().min(1).describe('Primary domain of the site, e.g. "example.com".'),
+        type: z.enum(SITE_TYPES).default('laravel').describe('Application type.'),
+        domain_mode: z
+            .enum(['custom', 'on-forge'])
+            .optional()
+            .describe('"custom" for your own domain, "on-forge" for a Forge-provided domain.'),
+        www_redirect_type: z.enum(['from-www', 'to-www', 'none']).optional().describe('www redirection for the domain.'),
+        allow_wildcard_subdomains: z.boolean().optional(),
+        php_version: z.enum(PHP_VERSIONS).optional().describe('PHP version; the server default when omitted.'),
+        web_directory: z.string().min(1).optional().describe('Public directory relative to the root, e.g. "/public".'),
+        root_directory: z.string().min(1).optional().describe('Project root directory.'),
+        is_isolated: z.boolean().optional().describe('Run the site as its own Linux user (website isolation).'),
+        isolated_user: z
+            .string()
+            .regex(/^[a-z][-a-z0-9_]*$/)
+            .max(32)
+            .optional()
+            .describe('Linux user for an isolated site.'),
+        zero_downtime_deployments: z.boolean().optional(),
+        shared_paths: z.array(sharedPath).optional().describe('Paths shared between releases with zero-downtime deployments.'),
+        nginx_template_id: z.number().int().optional().describe('Nginx template to use.'),
+        source_control_provider: z.enum(SOURCE_CONTROL_PROVIDERS).optional(),
+        source_control_provider_id: z.number().int().optional().describe('Source control connection to deploy through.'),
+        repository: z.string().min(1).optional().describe('Repository to install, e.g. "acme/app".'),
+        branch: z.string().min(1).optional().describe('Branch to deploy.'),
+        install_composer_dependencies: z.boolean().optional(),
+        generate_deploy_key: z.boolean().optional().describe('Generate a deploy key for this repository only.'),
+        push_to_deploy: z.boolean().optional().describe('Deploy automatically on every push to the branch.'),
+        database_id: z.number().int().optional().describe('Existing database to use with the site.'),
+        database_user_id: z.number().int().optional().describe('Existing database user to use with the site.'),
+        frontend_package_manager: z.string().min(1).optional().describe('Package manager for frontend apps, e.g. "npm".'),
+        frontend_build_command: z.string().min(1).optional().describe('Build command for frontend assets.'),
+        nuxt_next_mode: z.string().min(1).optional().describe('Render mode for Next.js / Nuxt.js apps.'),
+        nuxt_next_port: z.number().int().optional().describe('Port used by Next.js / Nuxt.js apps.'),
+        statamic_setup: z.string().min(1).optional().describe('Statamic setup type.'),
+        statamic_starter_kit: z.string().min(1).optional(),
+        statamic_super_user_email: z.string().email().optional(),
+        statamic_super_user_password: z.string().min(1).optional(),
+        tags: z.array(z.string().min(1)).optional(),
+        ...waitInput(300),
+    },
+    outputSchema: {
+        ...operationOutput,
+        site: siteOutput.nullable(),
+    },
+    async handler(args, { client, config, organization, signal, sleep, progress }) {
+        const org = organization(args.organization);
+        const { organization: _org, server, wait, timeout_seconds, ...body } = args;
+        const created = await client.post(apiPath `/orgs/${org}/servers/${server}/sites`, {
+            body,
+            signal,
+        });
+        const initial = created.data?.data ? flattenSingle(created.data) : undefined;
+        const format = (flat) => formatSite(flat, { detailed: false, allowSecrets: config.allowSecrets, serverId: String(server) });
+        const action = `create the site "${args.name}"`;
+        if (!initial) {
+            return {
+                structured: { status: 'queued', check_with: 'forge_list_sites', site: null },
+                summary: `Forge accepted the request to ${action}. Find it with forge_list_sites.`,
+            };
+        }
+        if (!wait) {
+            return {
+                structured: { status: 'queued', check_with: CHECK_WITH, site: format(initial) },
+                summary: `Forge is creating site ${initial.id}. Follow it with ${CHECK_WITH}.`,
+            };
+        }
+        const result = await waitFor({
+            initial,
+            poll: () => readSite(client, org, initial.id, signal),
+            phase: (site) => sitePhase(site.status),
+            describe: (site) => `Site ${site.id} is ${site.status}`,
+            timeoutSeconds: timeout_seconds,
+            context: { sleep, progress },
+        });
+        const site = format(result.value ?? initial);
+        const done = outcome(result, {
+            action,
+            checkWith: CHECK_WITH,
+            timeoutSeconds: timeout_seconds,
+            detail: result.status === 'completed' ? `Site ID ${site.id} on server ${site.server_id}; deploy it with forge_deploy_site.` : undefined,
+        });
+        return { structured: { ...done.structured, site }, summary: done.summary };
+    },
+});

package/dist/tools/sites/delete-site.js

@@ -0,0 +1,38 @@
+import { defineTool } from '../define-tool.js';
+import { operationOutput, orGone, outcome, queued, waitFor, waitInput } from '../shared/async.js';
+import { SITE_NOT_FOUND_HINT, siteScopeInput, sitePath } from '../shared/site-scope.js';
+import { readSite } from './shared.js';
+const CHECK_WITH = 'forge_list_sites';
+export const deleteSite = defineTool({
+    name: 'forge_delete_site',
+    title: 'Delete site',
+    description: 'Permanently delete a site from its server, including its files, Nginx configuration and certificates. Databases are kept. This cannot be undone.',
+    toolset: 'sites',
+    operations: ['organizations.servers.sites.destroy', 'organizations.sites.show'],
+    permissions: ['site:delete', 'server:view'],
+    readOnly: false,
+    destructive: true,
+    idempotent: true,
+    async: true,
+    notFoundHint: SITE_NOT_FOUND_HINT,
+    inputSchema: {
+        ...siteScopeInput,
+        ...waitInput(120),
+    },
+    outputSchema: operationOutput,
+    async handler(args, { client, organization, signal, sleep, progress }) {
+        const org = organization(args.organization);
+        await client.delete(sitePath(org, args.server, args.site), { signal });
+        const action = `delete site ${args.site}`;
+        if (!args.wait)
+            return queued(action, CHECK_WITH);
+        const result = await waitFor({
+            poll: () => orGone(() => readSite(client, org, args.site, signal)),
+            phase: (site) => (site === null ? 'completed' : 'pending'),
+            describe: (site) => `Site is ${site?.status ?? 'removing'}`,
+            timeoutSeconds: args.timeout_seconds,
+            context: { sleep, progress },
+        });
+        return outcome(result, { action, checkWith: CHECK_WITH, timeoutSeconds: args.timeout_seconds });
+    },
+});

package/dist/tools/sites/env-file.js

@@ -0,0 +1,52 @@
+/**
+ * Minimal, lossless editing of .env files: only the targeted keys change,
+ * every other line (comments, blank lines, ordering) is kept as is.
+ */
+export const ENV_KEY_PATTERN = /^[A-Za-z_][A-Za-z0-9_.]*$/;
+/** Formats a value so dotenv parsers read it back unchanged. */
+export function formatEnvValue(value) {
+    if (/^[A-Za-z0-9_.:/@,+\-=]*$/.test(value))
+        return value;
+    // Single quotes are literal (no interpolation, no escapes) when the value allows it.
+    if (!value.includes("'") && !value.includes('\n'))
+        return `'${value}'`;
+    return `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n')}"`;
+}
+function keyOf(line) {
+    return /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_.]*)\s*=/.exec(line)?.[1];
+}
+export function patchEnv(content, { set = {}, unset = [] }) {
+    const lines = content.length > 0 ? content.replace(/\n$/, '').split('\n') : [];
+    const updated = [];
+    const removed = [];
+    const pending = new Map(Object.entries(set));
+    const toRemove = new Set(unset);
+    const result = [];
+    for (const line of lines) {
+        const key = keyOf(line);
+        if (key !== undefined && toRemove.has(key)) {
+            if (!removed.includes(key))
+                removed.push(key);
+            continue;
+        }
+        if (key !== undefined && Object.hasOwn(set, key)) {
+            // Keep the first occurrence (updated in place) and drop duplicates.
+            if (!pending.has(key))
+                continue;
+            const exportPrefix = /^\s*export\s+/.test(line) ? 'export ' : '';
+            result.push(`${exportPrefix}${key}=${formatEnvValue(pending.get(key))}`);
+            pending.delete(key);
+            updated.push(key);
+            continue;
+        }
+        result.push(line);
+    }
+    const added = [...pending.keys()];
+    for (const [key, value] of pending)
+        result.push(`${key}=${formatEnvValue(value)}`);
+    return { content: `${result.join('\n')}\n`, updated, added, removed };
+}
+/** Whether two .env contents are the same, ignoring trailing whitespace. */
+export function sameEnv(a, b) {
+    return (a ?? '').trimEnd() === b.trimEnd();
+}

package/dist/tools/sites/environment.js

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { flattenSingle } from '../../forge/jsonapi.js';
+import { waitFor } from '../shared/async.js';
+import { sameEnv } from './env-file.js';
+/** Options of the environment update endpoint shared by the .env tools. */
+export const environmentUpdateOptions = {
+    cache: z.boolean().optional().describe('Cache the configuration after updating (`php artisan config:cache`).'),
+    queues: z.boolean().optional().describe('Restart queue workers after updating.'),
+};
+export async function readEnvironment(client, base, signal) {
+    const response = await client.get(`${base}/environment`, { signal });
+    return flattenSingle(response.data).content ?? '';
+}
+/** Writes the .env file and, when asked, waits until Forge serves the new content. */
+export async function writeEnvironment(client, base, content, options, context) {
+    await client.put(`${base}/environment`, {
+        body: { environment: content, cache: options.cache, queues: options.queues },
+        signal: context.signal,
+    });
+    if (!options.wait)
+        return undefined;
+    return waitFor({
+        poll: () => readEnvironment(client, base, context.signal),
+        phase: (current) => (sameEnv(current, content) ? 'completed' : 'pending'),
+        describe: () => 'Waiting for Forge to write the .env file',
+        timeoutSeconds: options.timeoutSeconds,
+        context,
+    });
+}

package/dist/tools/sites/get-site-environment.js

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { flattenSingle } from '../../forge/jsonapi.js';
+import { defineTool } from '../define-tool.js';
+import { SITE_NOT_FOUND_HINT, siteScopeInput, sitePath } from '../shared/site-scope.js';
+export const getSiteEnvironment = defineTool({
+    name: 'forge_get_site_environment',
+    title: 'Get site .env',
+    description: "Read the site's .env file. It contains secrets (database passwords, API keys): only share what the user needs. To change a few variables without reading the file, use forge_set_site_env_vars.",
+    toolset: 'sites',
+    operations: ['organizations.servers.sites.environment.show'],
+    permissions: ['server:view'],
+    readOnly: true,
+    exposesSecrets: true,
+    notFoundHint: SITE_NOT_FOUND_HINT,
+    inputSchema: siteScopeInput,
+    outputSchema: {
+        content: z.string().nullable().describe('Content of the .env file.'),
+    },
+    async handler(args, { client, organization, signal }) {
+        const response = await client.get(`${sitePath(organization(args.organization), args.server, args.site)}/environment`, { signal });
+        const content = flattenSingle(response.data).content ?? null;
+        return {
+            structured: { content },
+            summary: content ? `The .env file has ${content.trimEnd().split('\n').length} line(s).` : 'The site has no .env content.',
+        };
+    },
+});

package/dist/tools/sites/get-site-healthcheck.js

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { flattenSingle } from '../../forge/jsonapi.js';
+import { defineTool } from '../define-tool.js';
+import { SITE_NOT_FOUND_HINT, siteScopeInput, sitePath } from '../shared/site-scope.js';
+export const healthcheckOutput = {
+    healthcheck_endpoint: z.string().nullable().describe('URL Forge checks after zero-downtime deployments, or null.'),
+};
+export const getSiteHealthcheck = defineTool({
+    name: 'forge_get_site_healthcheck',
+    title: 'Get site healthcheck',
+    description: 'Get the healthcheck URL Forge calls to verify the site after zero-downtime deployments.',
+    toolset: 'sites',
+    operations: ['organizations.servers.sites.healthcheck.show'],
+    permissions: ['site:manage-project'],
+    readOnly: true,
+    notFoundHint: SITE_NOT_FOUND_HINT,
+    inputSchema: siteScopeInput,
+    outputSchema: healthcheckOutput,
+    async handler(args, { client, organization, signal }) {
+        const response = await client.get(`${sitePath(organization(args.organization), args.server, args.site)}/healthcheck`, { signal });
+        const endpoint = flattenSingle(response.data).healthcheck_endpoint ?? null;
+        return {
+            structured: { healthcheck_endpoint: endpoint },
+            summary: endpoint ? `Healthcheck endpoint: ${endpoint}.` : 'No healthcheck endpoint is configured.',
+        };
+    },
+});

package/dist/tools/sites/get-site-log.js

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+import { flattenSingle } from '../../forge/jsonapi.js';
+import { defineTool } from '../define-tool.js';
+import { tail } from '../shared/schemas.js';
+import { SITE_NOT_FOUND_HINT, siteScopeInput, sitePath } from '../shared/site-scope.js';
+import { siteLogInput } from './logs.js';
+export const getSiteLog = defineTool({
+    name: 'forge_get_site_log',
+    title: 'Get site log',
+    description: 'Read the end of a site log: the application log, the Nginx access log or the Nginx error log. Use it to diagnose errors after a deployment.',
+    toolset: 'sites',
+    operations: [
+        'organizations.servers.sites.logs.application.show',
+        'organizations.servers.sites.logs.nginx-access.show',
+        'organizations.servers.sites.logs.nginx-error.show',
+    ],
+    permissions: ['server:manage-logs'],
+    readOnly: true,
+    notFoundHint: SITE_NOT_FOUND_HINT,
+    inputSchema: {
+        ...siteScopeInput,
+        log: siteLogInput,
+        lines: z.number().int().min(0).max(5000).default(100).describe('Return only the last N lines (0 = everything Forge returns).'),
+    },
+    outputSchema: {
+        log: z.string(),
+        content: z.string().describe('Log content (last `lines` lines).'),
+        truncated: z.boolean(),
+        total_lines: z.number().int(),
+    },
+    async handler(args, { client, organization, signal }) {
+        const path = `${sitePath(organization(args.organization), args.server, args.site)}/logs/${args.log}`;
+        const response = await client.get(path, { signal });
+        const output = tail(flattenSingle(response.data).content, args.lines);
+        return {
+            structured: { log: args.log, content: output.text, truncated: output.truncated, total_lines: output.total_lines },
+            summary: output.total_lines === 0
+                ? `The ${args.log} log is empty.`
+                : `${args.log} log: ${output.truncated ? `last ${args.lines} of ${output.total_lines}` : output.total_lines} line(s).`,
+        };
+    },
+});

package/dist/tools/sites/get-site-nginx-config.js

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import { flattenSingle } from '../../forge/jsonapi.js';
+import { defineTool } from '../define-tool.js';
+import { SITE_NOT_FOUND_HINT, siteScopeInput, sitePath } from '../shared/site-scope.js';
+export const getSiteNginxConfig = defineTool({
+    name: 'forge_get_site_nginx_config',
+    title: 'Get site Nginx configuration',
+    description: "Read the site's Nginx configuration file (server blocks, locations, PHP-FPM socket, SSL settings).",
+    toolset: 'sites',
+    operations: ['organizations.servers.sites.nginx.show'],
+    permissions: ['server:view'],
+    readOnly: true,
+    notFoundHint: SITE_NOT_FOUND_HINT,
+    inputSchema: siteScopeInput,
+    outputSchema: {
+        content: z.string().nullable().describe('Nginx configuration of the site.'),
+    },
+    async handler(args, { client, organization, signal }) {
+        const response = await client.get(`${sitePath(organization(args.organization), args.server, args.site)}/nginx`, { signal });
+        const content = flattenSingle(response.data).content ?? null;
+        return {
+            structured: { content },
+            summary: content ? `The Nginx configuration has ${content.trimEnd().split('\n').length} line(s).` : 'No Nginx configuration found.',
+        };
+    },
+});

package/dist/tools/sites/logs.js

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+/** Site logs; each value is also the endpoint path segment (`/logs/<log>`). */
+export const siteLogInput = z
+    .enum(['application', 'nginx-access', 'nginx-error'])
+    .default('application')
+    .describe('"application": the app log (e.g. storage/logs/laravel.log); "nginx-access" / "nginx-error": the site\'s Nginx logs.');

package/dist/tools/sites/set-site-env-vars.js

@@ -0,0 +1,67 @@
+import { z } from 'zod';
+import { defineTool } from '../define-tool.js';
+import { ToolInputError } from '../errors.js';
+import { operationOutput, outcome, queued, waitInput } from '../shared/async.js';
+import { SITE_NOT_FOUND_HINT, siteScopeInput, sitePath } from '../shared/site-scope.js';
+import { ENV_KEY_PATTERN, patchEnv } from './env-file.js';
+import { environmentUpdateOptions, readEnvironment, writeEnvironment } from './environment.js';
+// Reading the file back needs FORGE_ALLOW_SECRETS; the tool itself never returns values.
+const CHECK_WITH = 'forge_get_site_environment';
+const envKey = z.string().regex(ENV_KEY_PATTERN, 'Invalid variable name');
+export const setSiteEnvVars = defineTool({
+    name: 'forge_set_site_env_vars',
+    title: 'Set site environment variables',
+    description: "Set or remove specific variables in a site's .env file, keeping every other line unchanged. The file content and current values are never returned, so this works without exposing secrets. Values are quoted automatically when needed.",
+    toolset: 'sites',
+    operations: ['organizations.servers.sites.environment.show', 'organizations.servers.sites.environment.update'],
+    permissions: ['server:view', 'site:manage-environment'],
+    readOnly: false,
+    destructive: false,
+    idempotent: true,
+    async: true,
+    notFoundHint: SITE_NOT_FOUND_HINT,
+    inputSchema: {
+        ...siteScopeInput,
+        set: z.record(envKey, z.string()).optional().describe('Variables to add or update, e.g. {"APP_DEBUG": "false"}.'),
+        unset: z.array(envKey).optional().describe('Variables to remove.'),
+        ...environmentUpdateOptions,
+        ...waitInput(60),
+    },
+    outputSchema: {
+        ...operationOutput,
+        updated: z.array(z.string()).describe('Existing variables that were set.'),
+        added: z.array(z.string()).describe('Variables appended to the file.'),
+        removed: z.array(z.string()).describe('Variables removed from the file.'),
+        not_found: z.array(z.string()).describe('Variables to remove that were not in the file.'),
+    },
+    async handler(args, { client, organization, signal, sleep, progress }) {
+        const set = args.set ?? {};
+        const unset = args.unset ?? [];
+        if (Object.keys(set).length === 0 && unset.length === 0) {
+            throw new ToolInputError('Nothing to change: pass `set` and/or `unset`.');
+        }
+        const conflicting = unset.filter((key) => Object.hasOwn(set, key));
+        if (conflicting.length > 0)
+            throw new ToolInputError(`Variables both set and unset: ${conflicting.join(', ')}.`);
+        const base = sitePath(organization(args.organization), args.server, args.site);
+        const current = await readEnvironment(client, base, signal);
+        const patch = patchEnv(current, { set, unset });
+        const notFound = unset.filter((key) => !patch.removed.includes(key));
+        const changes = { updated: patch.updated, added: patch.added, removed: patch.removed, not_found: notFound };
+        if (patch.updated.length + patch.added.length + patch.removed.length === 0) {
+            return {
+                structured: { status: 'completed', check_with: CHECK_WITH, ...changes },
+                summary: `Nothing to change: ${notFound.join(', ')} not found in the .env file.`,
+            };
+        }
+        const result = await writeEnvironment(client, base, patch.content, { cache: args.cache, queues: args.queues, wait: args.wait, timeoutSeconds: args.timeout_seconds }, { signal, sleep, progress });
+        const list = [...patch.updated, ...patch.added].join(', ');
+        const action = [list && `set ${list}`, patch.removed.length > 0 && `remove ${patch.removed.join(', ')}`]
+            .filter(Boolean)
+            .join(' and ');
+        const done = result
+            ? outcome(result, { action: `${action} in the .env file`, checkWith: CHECK_WITH, timeoutSeconds: args.timeout_seconds })
+            : queued(`${action} in the .env file`, CHECK_WITH);
+        return { structured: { ...done.structured, ...changes }, summary: done.summary };
+    },
+});

package/dist/tools/sites/shared.js

@@ -0,0 +1,42 @@
+import { flattenSingle } from '../../forge/jsonapi.js';
+import { apiPath } from '../../forge/path.js';
+import { phaseOf } from '../shared/async.js';
+export const SITE_TYPES = [
+    'laravel',
+    'symfony',
+    'statamic',
+    'wordpress',
+    'phpmyadmin',
+    'php',
+    'nextjs',
+    'nuxtjs',
+    'static-html',
+    'other',
+    'custom',
+];
+export const PHP_VERSIONS = [
+    'php5',
+    'php56-old',
+    'php56',
+    'php70',
+    'php71',
+    'php72',
+    'php73',
+    'php74',
+    'php80',
+    'php81',
+    'php82',
+    'php83',
+    'php84',
+    'php85',
+];
+export const SOURCE_CONTROL_PROVIDERS = ['github', 'gitlab', 'bitbucket', 'gitlab-custom', 'custom'];
+/** Reads a site by ID (the organization-level endpoint needs no server). */
+export async function readSite(client, org, site, signal) {
+    const response = await client.get(apiPath `/orgs/${org}/sites/${site}`, { signal });
+    return flattenSingle(response.data);
+}
+/** Site provisioning: transitional statuses from the SiteResource enum. */
+export function sitePhase(status) {
+    return phaseOf(status, { pending: ['creating', 'installing', 'removing', 'uninstalling'], failed: ['failed'] });
+}

package/dist/tools/sites/update-site-environment.js

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+import { defineTool } from '../define-tool.js';
+import { operationOutput, outcome, queued, waitInput } from '../shared/async.js';
+import { SITE_NOT_FOUND_HINT, siteScopeInput, sitePath } from '../shared/site-scope.js';
+import { environmentUpdateOptions, writeEnvironment } from './environment.js';
+const CHECK_WITH = 'forge_get_site_environment';
+export const updateSiteEnvironment = defineTool({
+    name: 'forge_update_site_environment',
+    title: 'Replace site .env',
+    description: "Replace the whole .env file of a site. Read it first with forge_get_site_environment and send the complete new content: anything omitted is lost. To change only some variables prefer forge_set_site_env_vars.",
+    toolset: 'sites',
+    operations: ['organizations.servers.sites.environment.update', 'organizations.servers.sites.environment.show'],
+    permissions: ['site:manage-environment', 'server:view'],
+    readOnly: false,
+    destructive: true,
+    idempotent: true,
+    async: true,
+    // Only usable safely after reading the full (secret) file, so it shares its opt-in.
+    exposesSecrets: true,
+    notFoundHint: SITE_NOT_FOUND_HINT,
+    inputSchema: {
+        ...siteScopeInput,
+        content: z.string().describe('The complete new .env content.'),
+        ...environmentUpdateOptions,
+        ...waitInput(60),
+    },
+    outputSchema: operationOutput,
+    async handler(args, { client, organization, signal, sleep, progress }) {
+        const base = sitePath(organization(args.organization), args.server, args.site);
+        const result = await writeEnvironment(client, base, args.content, { cache: args.cache, queues: args.queues, wait: args.wait, timeoutSeconds: args.timeout_seconds }, { signal, sleep, progress });
+        const action = 'replace the .env file';
+        return result ? outcome(result, { action, checkWith: CHECK_WITH, timeoutSeconds: args.timeout_seconds }) : queued(action, CHECK_WITH);
+    },
+});

package/dist/tools/sites/update-site-healthcheck.js

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { defineTool } from '../define-tool.js';
+import { SITE_NOT_FOUND_HINT, siteScopeInput, sitePath } from '../shared/site-scope.js';
+import { healthcheckOutput } from './get-site-healthcheck.js';
+export const updateSiteHealthcheck = defineTool({
+    name: 'forge_update_site_healthcheck',
+    title: 'Update site healthcheck',
+    description: 'Set or remove (null) the healthcheck URL Forge calls to verify the site after zero-downtime deployments.',
+    toolset: 'sites',
+    operations: ['organizations.servers.sites.healthcheck.update'],
+    permissions: ['site:manage-project'],
+    readOnly: false,
+    destructive: false,
+    idempotent: true,
+    notFoundHint: SITE_NOT_FOUND_HINT,
+    inputSchema: {
+        ...siteScopeInput,
+        healthcheck_endpoint: z.string().url().nullable().describe('Healthcheck URL, or null to remove it.'),
+    },
+    outputSchema: healthcheckOutput,
+    async handler(args, { client, organization, signal }) {
+        await client.put(`${sitePath(organization(args.organization), args.server, args.site)}/healthcheck`, {
+            body: { healthcheck_endpoint: args.healthcheck_endpoint },
+            signal,
+        });
+        return {
+            structured: { healthcheck_endpoint: args.healthcheck_endpoint },
+            summary: args.healthcheck_endpoint ? `Healthcheck set to ${args.healthcheck_endpoint}.` : 'Healthcheck removed.',
+        };
+    },
+});

package/dist/tools/sites/update-site-nginx-config.js

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+import { flattenSingle } from '../../forge/jsonapi.js';
+import { defineTool } from '../define-tool.js';
+import { operationOutput, outcome, queued, waitFor, waitInput } from '../shared/async.js';
+import { SITE_NOT_FOUND_HINT, siteScopeInput, sitePath } from '../shared/site-scope.js';
+const CHECK_WITH = 'forge_get_site_nginx_config';
+export const updateSiteNginxConfig = defineTool({
+    name: 'forge_update_site_nginx_config',
+    title: 'Replace site Nginx configuration',
+    description: "Replace the site's whole Nginx configuration and reload Nginx. Read it first with forge_get_site_nginx_config and send the complete new file: an invalid configuration can take the site (or every site on the server) offline.",
+    toolset: 'sites',
+    operations: ['organizations.servers.sites.nginx.update', 'organizations.servers.sites.nginx.show'],
+    permissions: ['site:manage-nginx', 'server:view'],
+    readOnly: false,
+    destructive: true,
+    idempotent: true,
+    async: true,
+    notFoundHint: SITE_NOT_FOUND_HINT,
+    inputSchema: {
+        ...siteScopeInput,
+        config: z.string().min(1).describe('The complete new Nginx configuration.'),
+        ...waitInput(60),
+    },
+    outputSchema: operationOutput,
+    async handler(args, { client, organization, signal, sleep, progress }) {
+        const path = `${sitePath(organization(args.organization), args.server, args.site)}/nginx`;
+        await client.put(path, { body: { config: args.config }, signal });
+        const action = 'update the Nginx configuration';
+        if (!args.wait)
+            return queued(action, CHECK_WITH);
+        const result = await waitFor({
+            poll: async () => {
+                const response = await client.get(path, { signal });
+                return flattenSingle(response.data).content ?? '';
+            },
+            phase: (content) => (content.trimEnd() === args.config.trimEnd() ? 'completed' : 'pending'),
+            describe: () => 'Waiting for Forge to apply the Nginx configuration',
+            timeoutSeconds: args.timeout_seconds,
+            context: { sleep, progress },
+        });
+        return outcome(result, {
+            action,
+            checkWith: CHECK_WITH,
+            timeoutSeconds: args.timeout_seconds,
+            detail: result.status === 'in_progress' ? 'If Nginx rejected the file, check forge_list_server_events.' : undefined,
+        });
+    },
+});

package/dist/tools/sites/update-site-repository.js

@@ -0,0 +1,68 @@
+import { z } from 'zod';
+import { flattenSingle } from '../../forge/jsonapi.js';
+import { defineTool } from '../define-tool.js';
+import { operationOutput, outcome, phaseOf, waitFor, waitInput } from '../shared/async.js';
+import { SITE_NOT_FOUND_HINT, siteScopeInput, sitePath } from '../shared/site-scope.js';
+import { formatSite, siteOutput } from './format.js';
+import { SOURCE_CONTROL_PROVIDERS, readSite } from './shared.js';
+const CHECK_WITH = 'forge_get_site';
+export const updateSiteRepository = defineTool({
+    name: 'forge_update_site_repository',
+    title: 'Update site repository',
+    description: 'Change the source control provider, repository or branch a site deploys from. Waits until Forge installs the repository unless `wait` is false; deploy afterwards with forge_deploy_site.',
+    toolset: 'sites',
+    operations: ['organizations.servers.sites.git.update', 'organizations.sites.show'],
+    permissions: ['site:manage-project', 'server:view'],
+    readOnly: false,
+    destructive: false,
+    idempotent: true,
+    async: true,
+    notFoundHint: SITE_NOT_FOUND_HINT,
+    inputSchema: {
+        ...siteScopeInput,
+        source_control_provider: z.enum(SOURCE_CONTROL_PROVIDERS),
+        source_control_provider_id: z
+            .number()
+            .int()
+            .optional()
+            .describe('Source control connection to deploy through, when the organization has several.'),
+        repository: z.string().min(1).describe('Repository, e.g. "acme/app" (or an SSH URL for custom Git).'),
+        branch: z.string().min(1).describe('Branch to deploy.'),
+        per_account_public_key: z.string().min(1).optional().describe('Existing deploy public key to pin to the site.'),
+        per_account_private_key: z.string().min(1).optional().describe('Private key matching per_account_public_key.'),
+        ...waitInput(120),
+    },
+    outputSchema: {
+        ...operationOutput,
+        site: siteOutput.nullable(),
+    },
+    async handler(args, { client, config, organization, signal, sleep, progress }) {
+        const org = organization(args.organization);
+        const { organization: _org, server, site, wait, timeout_seconds, ...body } = args;
+        const response = await client.put(`${sitePath(org, server, site)}/git`, { body, signal });
+        const initial = response.data?.data ? flattenSingle(response.data) : undefined;
+        const format = (flat) => formatSite(flat, { detailed: false, allowSecrets: config.allowSecrets, serverId: String(server) });
+        const action = `switch the site to ${args.repository}@${args.branch}`;
+        if (!wait) {
+            return {
+                structured: { status: 'queued', check_with: CHECK_WITH, site: initial ? format(initial) : null },
+                summary: `Forge accepted the request to ${action}. Follow it with ${CHECK_WITH}.`,
+            };
+        }
+        const result = await waitFor({
+            ...(initial ? { initial } : {}),
+            poll: () => readSite(client, org, site, signal),
+            phase: (current) => {
+                const repository = (current.repository ?? {});
+                const phase = phaseOf(repository.status, { pending: ['installing', 'removing'] });
+                return phase === 'completed' && repository.branch !== args.branch ? 'pending' : phase;
+            },
+            describe: (current) => `Repository is ${current.repository?.status ?? 'updating'}`,
+            timeoutSeconds: timeout_seconds,
+            context: { sleep, progress },
+        });
+        const done = outcome(result, { action, checkWith: CHECK_WITH, timeoutSeconds: timeout_seconds });
+        const latest = result.value ?? initial;
+        return { structured: { ...done.structured, site: latest ? format(latest) : null }, summary: done.summary };
+    },
+});

package/dist/tools/sites/update-site.js

@@ -0,0 +1,74 @@
+import { z } from 'zod';
+import { defineTool } from '../define-tool.js';
+import { ToolInputError } from '../errors.js';
+import { operationOutput, outcome, queued, waitFor, waitInput } from '../shared/async.js';
+import { SITE_NOT_FOUND_HINT, siteScopeInput, sitePath } from '../shared/site-scope.js';
+import { PHP_VERSIONS, SITE_TYPES, readSite } from './shared.js';
+const CHECK_WITH = 'forge_get_site';
+export const updateSite = defineTool({
+    name: 'forge_update_site',
+    title: 'Update site',
+    description: "Change a site's settings: PHP version, application type, web or root directory, deployed branch, push to deploy and zero-downtime release retention. Only the given fields change. To switch repository or provider use forge_update_site_repository.",
+    toolset: 'sites',
+    operations: ['organizations.servers.sites.update', 'organizations.sites.show'],
+    permissions: ['site:create', 'server:view'],
+    readOnly: false,
+    destructive: false,
+    idempotent: true,
+    async: true,
+    notFoundHint: SITE_NOT_FOUND_HINT,
+    inputSchema: {
+        ...siteScopeInput,
+        php_version: z.enum(PHP_VERSIONS).optional(),
+        type: z.enum(SITE_TYPES).optional().describe('Application type.'),
+        directory: z.string().min(1).optional().describe('Web (public) directory, e.g. "/public".'),
+        root_path: z.string().min(1).optional().describe('Project root directory.'),
+        repository_branch: z.string().min(1).optional().describe('Branch to deploy.'),
+        push_to_deploy: z.boolean().optional().describe('Deploy automatically on every push to the branch.'),
+        deployment_retention: z
+            .number()
+            .int()
+            .min(1)
+            .max(100)
+            .optional()
+            .describe('Zero-downtime releases to keep on the server.'),
+        ...waitInput(60),
+    },
+    outputSchema: operationOutput,
+    async handler(args, { client, organization, signal, sleep, progress }) {
+        const org = organization(args.organization);
+        const { organization: _org, server, site, wait, timeout_seconds, ...body } = args;
+        if (Object.values(body).every((value) => value === undefined)) {
+            throw new ToolInputError('Nothing to update: pass at least one setting to change.');
+        }
+        await client.put(sitePath(org, server, site), { body, signal });
+        // Settings that the site resource reflects; PHP version and type are applied but not exposed reliably.
+        const checks = [];
+        if (body.directory !== undefined)
+            checks.push({ field: 'web_directory', matches: (s) => s.web_directory === body.directory });
+        if (body.root_path !== undefined)
+            checks.push({ field: 'root_directory', matches: (s) => s.root_directory === body.root_path });
+        if (body.repository_branch !== undefined) {
+            checks.push({ field: 'branch', matches: (s) => s.repository?.branch === body.repository_branch });
+        }
+        if (body.push_to_deploy !== undefined)
+            checks.push({ field: 'quick_deploy', matches: (s) => s.quick_deploy === body.push_to_deploy });
+        if (body.deployment_retention !== undefined) {
+            checks.push({ field: 'deployment_retention', matches: (s) => s.deployment_retention === body.deployment_retention });
+        }
+        const action = 'update the site settings';
+        if (!wait)
+            return queued(action, CHECK_WITH);
+        if (checks.length === 0) {
+            return queued(action, CHECK_WITH, '(the site resource does not report PHP version and type changes)');
+        }
+        const result = await waitFor({
+            poll: () => readSite(client, org, site, signal),
+            phase: (current) => (checks.every((check) => check.matches(current)) ? 'completed' : 'pending'),
+            describe: (current) => `Waiting for ${checks.filter((check) => !check.matches(current)).map((c) => c.field).join(', ')}`,
+            timeoutSeconds: timeout_seconds,
+            context: { sleep, progress },
+        });
+        return outcome(result, { action, checkWith: CHECK_WITH, timeoutSeconds: timeout_seconds });
+    },
+});

package/package.json

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