@francescomalatesta/laravel-forge-mcp 0.7.0 → 0.8.0

package/README.md

@@ -127,6 +127,15 @@ npm run build
 | `forge_set_php_opcache` | servers | Enable or disable OPcache |
 | `forge_get_php_config` | servers | FPM or CLI php.ini, or the FPM pool configuration |
 | `forge_update_php_config` | servers | Replace a PHP configuration file |
+| `forge_list_databases` | databases | Database schemas on a server |
+| `forge_create_database` | databases | Create a database (optionally with a user) and wait until installed |
+| `forge_delete_database` | databases | Drop a database |
+| `forge_sync_databases` | databases | Import databases created outside Forge |
+| `forge_list_database_users` | databases | Database users on a server |
+| `forge_create_database_user` | databases | Create a user with access to databases (by ID or name) |
+| `forge_update_database_user` | databases | Change a user's password or databases |
+| `forge_delete_database_user` | databases | Delete a database user |
+| `forge_update_database_root_password` | databases | Change the database root password |
 | `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 |

package/dist/tools/databases/create-database-user.js

@@ -0,0 +1,65 @@
+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 { organizationInput, serverInput } from '../shared/schemas.js';
+import { SERVER_NOT_FOUND_HINT } from '../servers/shared.js';
+import { databaseOutput, databasePhase, databaseRefsInput, databaseUsersPath, formatDatabase, passwordInput, readOne, resolveDatabaseIds, } from './shared.js';
+const CHECK_WITH = 'forge_list_database_users';
+export const createDatabaseUser = defineTool({
+    name: 'forge_create_database_user',
+    title: 'Create database user',
+    description: 'Create a database user, optionally with access to some databases (by ID or name) and read-only. Waits until it is installed unless `wait` is false.',
+    toolset: 'databases',
+    operations: [
+        'organizations.servers.database.users.store',
+        'organizations.servers.database.users.show',
+        'organizations.servers.database.schemas.index',
+    ],
+    permissions: ['server:create-databases', 'server:view'],
+    readOnly: false,
+    destructive: false,
+    idempotent: false,
+    async: true,
+    notFoundHint: SERVER_NOT_FOUND_HINT,
+    inputSchema: {
+        organization: organizationInput,
+        server: serverInput,
+        name: z.string().min(1).describe('User name.'),
+        password: passwordInput,
+        databases: databaseRefsInput.optional(),
+        read_only: z.boolean().optional().describe('Grant read-only access.'),
+        ...waitInput(120),
+    },
+    outputSchema: {
+        ...operationOutput,
+        user: databaseOutput.nullable(),
+    },
+    async handler(args, { client, organization, signal, sleep, progress }) {
+        const org = organization(args.organization);
+        const databaseIds = args.databases ? await resolveDatabaseIds(client, org, args.server, args.databases, signal) : undefined;
+        const base = databaseUsersPath(org, args.server);
+        const response = await client.post(base, {
+            body: { name: args.name, password: args.password, database_ids: databaseIds, read_only: args.read_only },
+            signal,
+        });
+        const initial = response.data?.data ? flattenSingle(response.data) : undefined;
+        const action = `create the database user ${args.name}`;
+        if (!initial || !args.wait) {
+            return {
+                structured: { status: 'queued', check_with: CHECK_WITH, user: initial ? formatDatabase(initial) : null },
+                summary: `Forge accepted the request to ${action}. Check it with ${CHECK_WITH}.`,
+            };
+        }
+        const result = await waitFor({
+            initial,
+            poll: () => readOne(client, `${base}/${encodeURIComponent(initial.id)}`, signal),
+            phase: (user) => databasePhase(user.status),
+            describe: (user) => `Database user ${user.name} is ${user.status}`,
+            timeoutSeconds: args.timeout_seconds,
+            context: { sleep, progress },
+        });
+        const done = outcome(result, { action, checkWith: CHECK_WITH, timeoutSeconds: args.timeout_seconds });
+        return { structured: { ...done.structured, user: formatDatabase(result.value ?? initial) }, summary: done.summary };
+    },
+});

package/dist/tools/databases/create-database.js

@@ -0,0 +1,63 @@
+import { z } from 'zod';
+import { flattenSingle } from '../../forge/jsonapi.js';
+import { defineTool } from '../define-tool.js';
+import { ToolInputError } from '../errors.js';
+import { operationOutput, outcome, waitFor, waitInput } from '../shared/async.js';
+import { organizationInput, serverInput } from '../shared/schemas.js';
+import { SERVER_NOT_FOUND_HINT } from '../servers/shared.js';
+import { databaseOutput, databasePhase, databasesPath, formatDatabase, passwordInput, readOne } from './shared.js';
+const CHECK_WITH = 'forge_list_databases';
+export const createDatabase = defineTool({
+    name: 'forge_create_database',
+    title: 'Create database',
+    description: 'Create a database schema on a server, optionally with a new user that has access to it (`user` + `password`). Waits until it is installed unless `wait` is false. Connect it to a site by setting DB_* variables with forge_set_site_env_vars.',
+    toolset: 'databases',
+    operations: ['organizations.servers.database.schemas.store', 'organizations.servers.database.schemas.show'],
+    permissions: ['server:create-databases', 'server:view'],
+    readOnly: false,
+    destructive: false,
+    idempotent: false,
+    async: true,
+    notFoundHint: SERVER_NOT_FOUND_HINT,
+    inputSchema: {
+        organization: organizationInput,
+        server: serverInput,
+        name: z.string().min(1).describe('Database name.'),
+        user: z.string().min(1).optional().describe('Also create a user with access to this database.'),
+        password: passwordInput.optional().describe('Password of the new user (required with `user`, never returned).'),
+        backup_configuration_ids: z.array(z.number().int()).optional().describe('Backup configurations to add the database to.'),
+        ...waitInput(120),
+    },
+    outputSchema: {
+        ...operationOutput,
+        database: databaseOutput.nullable(),
+    },
+    async handler(args, { client, organization, signal, sleep, progress }) {
+        if (Boolean(args.user) !== Boolean(args.password)) {
+            throw new ToolInputError('Pass both `user` and `password` to create a user with the database, or neither.');
+        }
+        const base = databasesPath(organization(args.organization), args.server);
+        const response = await client.post(base, {
+            body: { name: args.name, user: args.user, password: args.password, backup_configuration_ids: args.backup_configuration_ids },
+            signal,
+        });
+        const initial = response.data?.data ? flattenSingle(response.data) : undefined;
+        const action = `create the database ${args.name}${args.user ? ` with user ${args.user}` : ''}`;
+        if (!initial || !args.wait) {
+            return {
+                structured: { status: 'queued', check_with: CHECK_WITH, database: initial ? formatDatabase(initial) : null },
+                summary: `Forge accepted the request to ${action}. Check it with ${CHECK_WITH}.`,
+            };
+        }
+        const result = await waitFor({
+            initial,
+            poll: () => readOne(client, `${base}/${encodeURIComponent(initial.id)}`, signal),
+            phase: (database) => databasePhase(database.status),
+            describe: (database) => `Database ${database.name} is ${database.status}`,
+            timeoutSeconds: args.timeout_seconds,
+            context: { sleep, progress },
+        });
+        const done = outcome(result, { action, checkWith: CHECK_WITH, timeoutSeconds: args.timeout_seconds });
+        return { structured: { ...done.structured, database: formatDatabase(result.value ?? initial) }, summary: done.summary };
+    },
+});

package/dist/tools/databases/delete-database-user.js

@@ -0,0 +1,40 @@
+import { defineTool } from '../define-tool.js';
+import { operationOutput, orGone, outcome, queued, waitFor, waitInput } from '../shared/async.js';
+import { organizationInput, serverInput } from '../shared/schemas.js';
+import { databaseUserInput, databaseUsersPath, readOne } from './shared.js';
+const CHECK_WITH = 'forge_list_database_users';
+export const deleteDatabaseUser = defineTool({
+    name: 'forge_delete_database_user',
+    title: 'Delete database user',
+    description: 'Delete a database user. Applications connecting with it lose database access.',
+    toolset: 'databases',
+    operations: ['organizations.servers.database.users.destroy', 'organizations.servers.database.users.show'],
+    permissions: ['server:delete-databases', 'server:view'],
+    readOnly: false,
+    destructive: true,
+    idempotent: true,
+    async: true,
+    notFoundHint: 'Check the user ID with forge_list_database_users.',
+    inputSchema: {
+        organization: organizationInput,
+        server: serverInput,
+        user: databaseUserInput,
+        ...waitInput(120),
+    },
+    outputSchema: operationOutput,
+    async handler(args, { client, organization, signal, sleep, progress }) {
+        const path = `${databaseUsersPath(organization(args.organization), args.server)}/${encodeURIComponent(String(args.user))}`;
+        await client.delete(path, { signal });
+        const action = `delete database user ${args.user}`;
+        if (!args.wait)
+            return queued(action, CHECK_WITH);
+        const result = await waitFor({
+            poll: () => orGone(() => readOne(client, path, signal)),
+            phase: (user) => (user === null ? 'completed' : 'pending'),
+            describe: (user) => `Database user is ${user?.status ?? 'removing'}`,
+            timeoutSeconds: args.timeout_seconds,
+            context: { sleep, progress },
+        });
+        return outcome(result, { action, checkWith: CHECK_WITH, timeoutSeconds: args.timeout_seconds });
+    },
+});

package/dist/tools/databases/delete-database.js

@@ -0,0 +1,40 @@
+import { defineTool } from '../define-tool.js';
+import { operationOutput, orGone, outcome, queued, waitFor, waitInput } from '../shared/async.js';
+import { organizationInput, serverInput } from '../shared/schemas.js';
+import { databaseInput, databasesPath, readOne } from './shared.js';
+const CHECK_WITH = 'forge_list_databases';
+export const deleteDatabase = defineTool({
+    name: 'forge_delete_database',
+    title: 'Delete database',
+    description: 'Drop a database schema from the server with all its data. This cannot be undone: make sure a backup exists.',
+    toolset: 'databases',
+    operations: ['organizations.servers.database.schemas.destroy', 'organizations.servers.database.schemas.show'],
+    permissions: ['server:delete-databases', 'server:view'],
+    readOnly: false,
+    destructive: true,
+    idempotent: true,
+    async: true,
+    notFoundHint: 'Check the database ID with forge_list_databases.',
+    inputSchema: {
+        organization: organizationInput,
+        server: serverInput,
+        database: databaseInput,
+        ...waitInput(120),
+    },
+    outputSchema: operationOutput,
+    async handler(args, { client, organization, signal, sleep, progress }) {
+        const path = `${databasesPath(organization(args.organization), args.server)}/${encodeURIComponent(String(args.database))}`;
+        await client.delete(path, { signal });
+        const action = `delete database ${args.database}`;
+        if (!args.wait)
+            return queued(action, CHECK_WITH);
+        const result = await waitFor({
+            poll: () => orGone(() => readOne(client, path, signal)),
+            phase: (database) => (database === null ? 'completed' : 'pending'),
+            describe: (database) => `Database is ${database?.status ?? 'removing'}`,
+            timeoutSeconds: args.timeout_seconds,
+            context: { sleep, progress },
+        });
+        return outcome(result, { action, checkWith: CHECK_WITH, timeoutSeconds: args.timeout_seconds });
+    },
+});

package/dist/tools/databases/list-database-users.js

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+import { flattenCollection } from '../../forge/jsonapi.js';
+import { defineTool } from '../define-tool.js';
+import { organizationInput, paginationInput, paginationOutput, paginationSummary, serverInput } from '../shared/schemas.js';
+import { SERVER_NOT_FOUND_HINT } from '../servers/shared.js';
+import { databaseOutput, databaseUserInput, databaseUsersPath, formatDatabase, readOne } from './shared.js';
+const SORT = ['name', '-name', 'created_at', '-created_at', 'updated_at', '-updated_at'];
+export const listDatabaseUsers = defineTool({
+    name: 'forge_list_database_users',
+    title: 'List database users',
+    description: 'List the database users on a server, or get one with `user`. Passwords and granted databases are not exposed by Forge.',
+    toolset: 'databases',
+    operations: ['organizations.servers.database.users.index', 'organizations.servers.database.users.show'],
+    permissions: ['server:view'],
+    readOnly: true,
+    notFoundHint: SERVER_NOT_FOUND_HINT,
+    inputSchema: {
+        organization: organizationInput,
+        server: serverInput,
+        user: databaseUserInput.optional().describe('Return only this user.'),
+        name: z.string().min(1).optional().describe('Filter by name.'),
+        status: z.string().min(1).optional().describe('Filter by status, e.g. "installed".'),
+        sort: z.array(z.enum(SORT)).min(1).optional(),
+        ...paginationInput,
+    },
+    outputSchema: {
+        users: z.array(databaseOutput),
+        ...paginationOutput,
+    },
+    async handler(args, { client, organization, signal }) {
+        const base = databaseUsersPath(organization(args.organization), args.server);
+        if (args.user !== undefined) {
+            const user = formatDatabase(await readOne(client, `${base}/${encodeURIComponent(String(args.user))}`, signal));
+            return { structured: { users: [user], next_cursor: null, has_more: false }, summary: `Database user ${user.name} is ${user.status}.` };
+        }
+        const response = await client.get(base, {
+            query: { filter: { name: args.name, status: args.status }, sort: args.sort, page: { size: args.page_size, cursor: args.cursor } },
+            signal,
+        });
+        const page = flattenCollection(response.data);
+        const users = page.items.map(formatDatabase);
+        return {
+            structured: { users, next_cursor: page.nextCursor, has_more: page.nextCursor !== null },
+            summary: users.length === 0
+                ? 'No database users found.'
+                : `Found ${users.length} database user(s): ${users.map((u) => u.name).join(', ')}.${paginationSummary(page.nextCursor)}`,
+        };
+    },
+});

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

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+import { flattenCollection } from '../../forge/jsonapi.js';
+import { defineTool } from '../define-tool.js';
+import { organizationInput, paginationInput, paginationOutput, paginationSummary, serverInput } from '../shared/schemas.js';
+import { SERVER_NOT_FOUND_HINT } from '../servers/shared.js';
+import { databaseInput, databaseOutput, databasesPath, formatDatabase, readOne } from './shared.js';
+const SORT = ['name', '-name', 'created_at', '-created_at', 'updated_at', '-updated_at'];
+export const listDatabases = defineTool({
+    name: 'forge_list_databases',
+    title: 'List databases',
+    description: 'List the database schemas on a server (MySQL, MariaDB or Postgres), or get one with `database`.',
+    toolset: 'databases',
+    operations: ['organizations.servers.database.schemas.index', 'organizations.servers.database.schemas.show'],
+    permissions: ['server:view'],
+    readOnly: true,
+    notFoundHint: SERVER_NOT_FOUND_HINT,
+    inputSchema: {
+        organization: organizationInput,
+        server: serverInput,
+        database: databaseInput.optional().describe('Return only this database.'),
+        name: z.string().min(1).optional().describe('Filter by name.'),
+        status: z.string().min(1).optional().describe('Filter by status, e.g. "installed".'),
+        sort: z.array(z.enum(SORT)).min(1).optional(),
+        ...paginationInput,
+    },
+    outputSchema: {
+        databases: z.array(databaseOutput),
+        ...paginationOutput,
+    },
+    async handler(args, { client, organization, signal }) {
+        const base = databasesPath(organization(args.organization), args.server);
+        if (args.database !== undefined) {
+            const database = formatDatabase(await readOne(client, `${base}/${encodeURIComponent(String(args.database))}`, signal));
+            return { structured: { databases: [database], next_cursor: null, has_more: false }, summary: `Database ${database.name} is ${database.status}.` };
+        }
+        const response = await client.get(base, {
+            query: { filter: { name: args.name, status: args.status }, sort: args.sort, page: { size: args.page_size, cursor: args.cursor } },
+            signal,
+        });
+        const page = flattenCollection(response.data);
+        const databases = page.items.map(formatDatabase);
+        return {
+            structured: { databases, next_cursor: page.nextCursor, has_more: page.nextCursor !== null },
+            summary: databases.length === 0
+                ? 'No databases found.'
+                : `Found ${databases.length} database(s): ${databases.map((d) => d.name).join(', ')}.${paginationSummary(page.nextCursor)}`,
+        };
+    },
+});

package/dist/tools/databases/shared.js

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+import { flattenCollection, flattenSingle } from '../../forge/jsonapi.js';
+import { ToolInputError } from '../errors.js';
+import { phaseOf } from '../shared/async.js';
+import { idInput, pick } from '../shared/schemas.js';
+import { serverPath } from '../servers/shared.js';
+export function databasesPath(org, server) {
+    return `${serverPath(org, server)}/database/schemas`;
+}
+export function databaseUsersPath(org, server) {
+    return `${serverPath(org, server)}/database/users`;
+}
+export const databaseInput = idInput('Database ID. Use forge_list_databases to find it.');
+export const databaseUserInput = idInput('Database user ID. Use forge_list_database_users to find it.');
+export const databaseRefsInput = z
+    .array(z.union([z.number().int().nonnegative(), z.string().min(1)]))
+    .describe('Databases by ID or by name, e.g. [12, "shop"].');
+export const passwordInput = z.string().min(8).describe('Password (never returned by any tool).');
+const FIELDS = ['id', 'name', 'status', 'created_at', 'updated_at'];
+export const databaseOutput = z.looseObject({
+    id: z.string(),
+    name: z.string().nullable(),
+    status: z.string().nullable().describe('installing, installed, removing (users also: updating).'),
+    created_at: z.string().nullable(),
+    updated_at: z.string().nullable(),
+});
+export function formatDatabase(flat) {
+    return pick(flat, FIELDS);
+}
+export async function readOne(client, path, signal) {
+    const response = await client.get(path, { signal });
+    return flattenSingle(response.data);
+}
+/** Databases and database users share the same transitional statuses. */
+export function databasePhase(status) {
+    return phaseOf(status, { pending: ['installing', 'updating', 'removing'] });
+}
+/** Resolves database IDs or names to IDs, failing with the names that do not exist. */
+export async function resolveDatabaseIds(client, org, server, refs, signal) {
+    const ids = [];
+    const missing = [];
+    for (const ref of refs) {
+        if (typeof ref === 'number' || /^\d+$/.test(ref)) {
+            ids.push(Number(ref));
+            continue;
+        }
+        const response = await client.get(databasesPath(org, server), {
+            query: { filter: { name: ref }, page: { size: 100 } },
+            signal,
+        });
+        const match = flattenCollection(response.data).items.find((database) => database.name === ref);
+        if (match)
+            ids.push(Number(match.id));
+        else
+            missing.push(ref);
+    }
+    if (missing.length > 0) {
+        throw new ToolInputError(`Database(s) not found on server ${server}: ${missing.join(', ')}. Check the names with forge_list_databases.`);
+    }
+    return ids;
+}

package/dist/tools/databases/sync-databases.js

@@ -0,0 +1,28 @@
+import { defineTool } from '../define-tool.js';
+import { operationOutput, queued } from '../shared/async.js';
+import { organizationInput, serverInput } from '../shared/schemas.js';
+import { SERVER_NOT_FOUND_HINT } from '../servers/shared.js';
+import { databasesPath } from './shared.js';
+export const syncDatabases = defineTool({
+    name: 'forge_sync_databases',
+    title: 'Synchronize databases',
+    description: 'Make Forge pick up databases created outside Forge (e.g. from a SQL client), so they can be managed and backed up.',
+    toolset: 'databases',
+    operations: ['organizations.servers.database.schemas.synchronizations.store'],
+    permissions: ['server:create-databases'],
+    readOnly: false,
+    destructive: false,
+    idempotent: true,
+    async: true,
+    notFoundHint: SERVER_NOT_FOUND_HINT,
+    inputSchema: {
+        organization: organizationInput,
+        server: serverInput,
+    },
+    outputSchema: operationOutput,
+    async handler(args, { client, organization, signal }) {
+        await client.post(`${databasesPath(organization(args.organization), args.server)}/synchronizations`, { signal });
+        // Which databases will appear is unknown in advance, so there is nothing to wait for.
+        return queued('synchronize the databases', 'forge_list_databases');
+    },
+});

package/dist/tools/databases/update-database-root-password.js

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import { defineTool } from '../define-tool.js';
+import { organizationInput, serverInput } from '../shared/schemas.js';
+import { SERVER_NOT_FOUND_HINT, serverPath } from '../servers/shared.js';
+import { passwordInput } from './shared.js';
+export const updateDatabaseRootPassword = defineTool({
+    name: 'forge_update_database_root_password',
+    title: 'Change database root password',
+    description: "Change the password of the database server's root user (the `forge` user on Forge-provisioned servers). Applications or tools using the old root password stop connecting.",
+    toolset: 'databases',
+    operations: ['organizations.servers.database.password.update'],
+    permissions: ['server:manage-services'],
+    readOnly: false,
+    destructive: true,
+    idempotent: true,
+    notFoundHint: SERVER_NOT_FOUND_HINT,
+    inputSchema: {
+        organization: organizationInput,
+        server: serverInput,
+        password: passwordInput.describe('New root password (never returned).'),
+    },
+    outputSchema: {
+        updated: z.boolean(),
+    },
+    async handler(args, { client, organization, signal }) {
+        await client.put(`${serverPath(organization(args.organization), args.server)}/database/password`, {
+            body: { password: args.password },
+            signal,
+        });
+        return { structured: { updated: true }, summary: 'Database root password changed.' };
+    },
+});

package/dist/tools/databases/update-database-user.js

@@ -0,0 +1,39 @@
+import { defineTool } from '../define-tool.js';
+import { ToolInputError } from '../errors.js';
+import { operationOutput, queued } from '../shared/async.js';
+import { organizationInput, serverInput } from '../shared/schemas.js';
+import { databaseRefsInput, databaseUserInput, databaseUsersPath, passwordInput, resolveDatabaseIds } from './shared.js';
+export const updateDatabaseUser = defineTool({
+    name: 'forge_update_database_user',
+    title: 'Update database user',
+    description: "Change a database user's password and/or the databases it can access. `databases` replaces the whole list (by ID or name): include the ones it should keep.",
+    toolset: 'databases',
+    operations: ['organizations.servers.database.users.update', 'organizations.servers.database.schemas.index'],
+    permissions: ['server:create-databases', 'server:view'],
+    readOnly: false,
+    destructive: false,
+    idempotent: true,
+    async: true,
+    notFoundHint: 'Check the user ID with forge_list_database_users.',
+    inputSchema: {
+        organization: organizationInput,
+        server: serverInput,
+        user: databaseUserInput,
+        password: passwordInput.optional().describe('New password (never returned).'),
+        databases: databaseRefsInput.optional().describe('Every database the user should access, by ID or name (replaces the list).'),
+    },
+    outputSchema: operationOutput,
+    async handler(args, { client, organization, signal }) {
+        if (args.password === undefined && args.databases === undefined) {
+            throw new ToolInputError('Pass `password` and/or `databases`.');
+        }
+        const org = organization(args.organization);
+        const databaseIds = args.databases ? await resolveDatabaseIds(client, org, args.server, args.databases, signal) : undefined;
+        await client.put(`${databaseUsersPath(org, args.server)}/${encodeURIComponent(String(args.user))}`, {
+            body: { password: args.password, database_ids: databaseIds },
+            signal,
+        });
+        // Neither passwords nor granted databases are exposed by the API: nothing to verify.
+        return queued(`update database user ${args.user}`, 'forge_list_database_users', '(the status shows "updating" while it runs)');
+    },
+});

package/dist/tools/registry.js

@@ -3,6 +3,15 @@ import { deleteCertificate } from './certificates/delete-certificate.js';
 import { getCertificate } from './certificates/get-certificate.js';
 import { listCertificates } from './certificates/list-certificates.js';
 import { runCertificateAction } from './certificates/run-certificate-action.js';
+import { createDatabase } from './databases/create-database.js';
+import { createDatabaseUser } from './databases/create-database-user.js';
+import { deleteDatabase } from './databases/delete-database.js';
+import { deleteDatabaseUser } from './databases/delete-database-user.js';
+import { listDatabaseUsers } from './databases/list-database-users.js';
+import { listDatabases } from './databases/list-databases.js';
+import { syncDatabases } from './databases/sync-databases.js';
+import { updateDatabaseRootPassword } from './databases/update-database-root-password.js';
+import { updateDatabaseUser } from './databases/update-database-user.js';
 import { createDeployKey } from './deployments/create-deploy-key.js';
 import { createDeploymentWebhook } from './deployments/create-deployment-webhook.js';
 import { deleteDeployKey } from './deployments/delete-deploy-key.js';
@@ -127,6 +136,16 @@ export const ALL_TOOLS = [
     setPhpOpcache,
     getPhpConfig,
     updatePhpConfig,
+    // databases
+    listDatabases,
+    createDatabase,
+    deleteDatabase,
+    syncDatabases,
+    listDatabaseUsers,
+    createDatabaseUser,
+    updateDatabaseUser,
+    deleteDatabaseUser,
+    updateDatabaseRootPassword,
     // deployments
     listDeployments,
     getDeployment,

package/package.json

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