@hostinger/mcp 3.38.4 → 3.39.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (43) hide show
  1. package/CHANGELOG.md +18 -0
  2. package/README.md +126 -9
  3. package/gemini-extension.json +1 -1
  4. package/package.json +1 -1
  5. package/server.json +2 -2
  6. package/skills/headless/VERSION +1 -1
  7. package/src/core/runtime.js +1 -1
  8. package/src/core/runtime.ts +1 -1
  9. package/src/core/tools/all.js +192 -4
  10. package/src/core/tools/all.ts +192 -4
  11. package/src/core/tools/hosting.js +190 -2
  12. package/src/core/tools/hosting.ts +190 -2
  13. package/src/core/tools/wordpress.js +2 -2
  14. package/src/core/tools/wordpress.ts +2 -2
  15. package/src/servers/agency-hosting.js +1 -1
  16. package/src/servers/agency-hosting.ts +1 -1
  17. package/src/servers/agent-readiness.js +1 -1
  18. package/src/servers/agent-readiness.ts +1 -1
  19. package/src/servers/all.js +1 -1
  20. package/src/servers/all.ts +1 -1
  21. package/src/servers/billing.js +1 -1
  22. package/src/servers/billing.ts +1 -1
  23. package/src/servers/dns.js +1 -1
  24. package/src/servers/dns.ts +1 -1
  25. package/src/servers/domains.js +1 -1
  26. package/src/servers/domains.ts +1 -1
  27. package/src/servers/ecommerce.js +1 -1
  28. package/src/servers/ecommerce.ts +1 -1
  29. package/src/servers/gpu.js +1 -1
  30. package/src/servers/gpu.ts +1 -1
  31. package/src/servers/horizons.js +1 -1
  32. package/src/servers/horizons.ts +1 -1
  33. package/src/servers/hosting.js +1 -1
  34. package/src/servers/hosting.ts +1 -1
  35. package/src/servers/mail.js +1 -1
  36. package/src/servers/mail.ts +1 -1
  37. package/src/servers/reach.js +1 -1
  38. package/src/servers/reach.ts +1 -1
  39. package/src/servers/vps.js +1 -1
  40. package/src/servers/vps.ts +1 -1
  41. package/src/servers/wordpress.js +1 -1
  42. package/src/servers/wordpress.ts +1 -1
  43. package/types.d.ts +190 -9
package/types.d.ts CHANGED
@@ -5376,10 +5376,14 @@ root with the admin user, email and password from `wordpress`, the domain as the
5376
5376
  title, and `en_US` when `wordpress.language` is omitted. The headless types
5377
5377
  (`headless_empty`, `headless_wordpress`, `headless_ecommerce`, `headless_pocketbase`)
5378
5378
  create a headless website; `headless_wordpress` additionally installs WordPress into the
5379
- `cms` directory of the website root with generated credentials. `headless_empty` installs
5380
- nothing: WordPress can be added later through
5381
- `POST /api/hosting/v1/accounts/{username}/wordpress/installations`
5382
- (`wordpress_installations_install`) with `type: headless`.
5379
+ `cms` directory of the website root with generated credentials. `headless_pocketbase`
5380
+ marks the website as a headless PocketBase website but installs nothing: create its
5381
+ PocketBase backend with `Create PocketBase backend`
5382
+ (`POST /api/hosting/v1/accounts/{username}/websites/{domain}/pocketbase`) once the setup
5383
+ is `completed`. `headless_empty` installs nothing either: WordPress can be added later
5384
+ through `POST /api/hosting/v1/accounts/{username}/wordpress/installations`
5385
+ (`wordpress_installations_install`) with `type: headless`, or a PocketBase backend through
5386
+ the same PocketBase endpoint.
5383
5387
 
5384
5388
  Omit `domain` to set the website up on a generated temporary free subdomain; the created
5385
5389
  setup returns it as `domain`. REST clients that need to know the free subdomain before the
@@ -5400,7 +5404,7 @@ running.
5400
5404
  */
5401
5405
  order_id: number;
5402
5406
  /**
5403
- * Website type. Omit or `null` for an empty website. `wordpress` installs WordPress in the website root and requires `wordpress`. The headless types (`headless_empty`, `headless_wordpress`, `headless_ecommerce`, `headless_pocketbase`) create a headless website; `headless_wordpress` additionally installs WordPress into the `cms` directory with generated credentials. `headless_empty` installs nothing, so WordPress can be added later through `POST /api/hosting/v1/accounts/{username}/wordpress/installations` (`wordpress_installations_install`) with `type: headless`.
5407
+ * Website type. Omit or `null` for an empty website. `wordpress` installs WordPress in the website root and requires `wordpress`. The headless types (`headless_empty`, `headless_wordpress`, `headless_ecommerce`, `headless_pocketbase`) create a headless website; `headless_wordpress` additionally installs WordPress into the `cms` directory with generated credentials. `headless_pocketbase` only marks the website as a headless PocketBase website: create the backend afterwards with `Create PocketBase backend` (`POST /api/hosting/v1/accounts/{username}/websites/{domain}/pocketbase`). `headless_empty` installs nothing, so WordPress can be added later through `POST /api/hosting/v1/accounts/{username}/wordpress/installations` (`wordpress_installations_install`) with `type: headless`, or a PocketBase backend through the PocketBase endpoint.
5404
5408
  */
5405
5409
  type?: string;
5406
5410
  /**
@@ -5587,6 +5591,181 @@ Use the Get PHP details endpoint to see the versions available for the website.
5587
5591
  response: any; // Response structure will depend on the API
5588
5592
  };
5589
5593
 
5594
+ /**
5595
+ * Returns the PocketBase backend of a website: its REST API and dashboard URLs, live state
5596
+ and version. A PocketBase backend gives the website a database, authentication, file
5597
+ storage and a realtime REST API, served from the website's own domain under `/api` and
5598
+ `/_`. Returns 404 when the website has no PocketBase backend.
5599
+
5600
+ The superuser password is only shown once, when it is set, and is never returned here. If it
5601
+ is lost, set a new one with the `Set PocketBase superuser` endpoint.
5602
+
5603
+ The instance sleeps when idle and wakes on the first request, so `asleep` is a normal state
5604
+ and the first call to a sleeping instance can take a few seconds. `starting`, `running` and
5605
+ `stopping` are healthy; `failed` or `unregistered` mean the instance is broken; `missing`
5606
+ means its files are gone from the server, and creating the PocketBase backend again sets up
5607
+ a new, empty one. `state` is null when the server could not be reached; retry later.
5608
+
5609
+ PocketBase is rolling out gradually: an account without access yet gets 422.
5610
+ */
5611
+ "hosting_pocketbase_backend": {
5612
+ params: {
5613
+ /**
5614
+ * username parameter
5615
+ */
5616
+ username: string;
5617
+ /**
5618
+ * Domain name
5619
+ */
5620
+ domain: string;
5621
+ };
5622
+ response: any; // Response structure will depend on the API
5623
+ };
5624
+
5625
+ /**
5626
+ * Creates a PocketBase backend for a website: a database, authentication, file storage and a
5627
+ realtime REST API, served from the website's own domain. A website has at most one
5628
+ PocketBase backend. Creation usually takes a few seconds.
5629
+
5630
+ The backend takes over the `/api` and `/_` paths of the website: from then on requests to
5631
+ these paths and everything below them go to PocketBase, while every other path keeps
5632
+ serving the website. Do not create a backend for a website that serves its own `/api` or
5633
+ `/_` paths, because they stop working; confirm with the user before calling it. Deleting
5634
+ the backend gives both paths back to the website. Headless WordPress websites and parked
5635
+ domains are not supported; for a parked domain, use the website it is parked on. A website
5636
+ that already has a backend is rejected with 422, unless that backend is in state
5637
+ `missing`: then it is replaced with a new, empty one. A website set up with
5638
+ `type: headless_empty` becomes `headless_pocketbase`; any other website keeps its type.
5639
+
5640
+ `superuser_password` is optional: leave it out to get a strong generated password, or send
5641
+ your own (10-128 characters). The response returns it in `superuser_password` once and
5642
+ Hostinger never stores it, so save it in your app secrets right away; you need it to manage
5643
+ the backend through the PocketBase REST API. If it is lost, set a new one with the
5644
+ `Set PocketBase superuser` endpoint. `superuser_email` defaults to the email of the
5645
+ website owner.
5646
+
5647
+ The instance sleeps when idle and wakes on the first request, so the first call after a
5648
+ quiet period can take a few seconds. `next_steps` in the response lists what to do next.
5649
+
5650
+ PocketBase is rolling out gradually: an account without access yet gets 422.
5651
+ */
5652
+ "hosting_pocketbase_create-backend": {
5653
+ params: {
5654
+ /**
5655
+ * username parameter
5656
+ */
5657
+ username: string;
5658
+ /**
5659
+ * Domain name
5660
+ */
5661
+ domain: string;
5662
+ /**
5663
+ * Email of the PocketBase superuser. Defaults to the email of the website owner.
5664
+ */
5665
+ superuser_email?: string;
5666
+ /**
5667
+ * Password for the PocketBase superuser, 10-128 characters. Leave it out to have a strong one
5668
+ generated. Either way it is returned once in the response and never stored.
5669
+ */
5670
+ superuser_password?: string;
5671
+ };
5672
+ response: any; // Response structure will depend on the API
5673
+ };
5674
+
5675
+ /**
5676
+ * Permanently deletes the PocketBase backend of a website with all its data (collections,
5677
+ records, users and uploaded files) and gives the `/api` and `/_` paths back to the website;
5678
+ a `headless_pocketbase` website becomes `headless_empty`. This cannot be undone and every
5679
+ app using this backend stops working, so confirm with the user before calling it and
5680
+ export the data you need from the dashboard (`admin_url`) first.
5681
+
5682
+ Returns success also when the website has no PocketBase backend; then it only clears a
5683
+ `headless_pocketbase` mark. To regain access after losing the superuser password, use the
5684
+ `Set PocketBase superuser` endpoint instead of deleting the backend.
5685
+
5686
+ PocketBase is rolling out gradually: an account without access yet gets 422; an unknown
5687
+ website gets 404.
5688
+ */
5689
+ "hosting_pocketbase_delete-backend": {
5690
+ params: {
5691
+ /**
5692
+ * username parameter
5693
+ */
5694
+ username: string;
5695
+ /**
5696
+ * Domain name
5697
+ */
5698
+ domain: string;
5699
+ };
5700
+ response: any; // Response structure will depend on the API
5701
+ };
5702
+
5703
+ /**
5704
+ * Lists the PocketBase backends of all websites of a hosting account with their URLs, live
5705
+ state, version and disk usage. A PocketBase backend gives a website a database,
5706
+ authentication, file storage and a realtime REST API, served from the website's own
5707
+ domain. An empty list means no website of the account has a PocketBase backend.
5708
+
5709
+ States: `asleep` is normal (the instance sleeps when idle and wakes on the first request);
5710
+ `starting`, `running` and `stopping` are healthy; `failed` or `unregistered` mean the
5711
+ instance is broken; `missing` means its files are gone from the server, and creating the
5712
+ PocketBase backend again sets up a new, empty one. `state` is null when the server could
5713
+ not be reached; retry later.
5714
+
5715
+ PocketBase is rolling out gradually: an account without access yet gets 422.
5716
+ */
5717
+ "hosting_pocketbase_list-backends": {
5718
+ params: {
5719
+ /**
5720
+ * username parameter
5721
+ */
5722
+ username: string;
5723
+ };
5724
+ response: any; // Response structure will depend on the API
5725
+ };
5726
+
5727
+ /**
5728
+ * Sets the password of a superuser of the website's PocketBase backend, and creates that
5729
+ superuser when there is none with the given email. The old password of that superuser stops
5730
+ working at once, so apps and scripts still using it lose superuser access; confirm with the
5731
+ user before calling it.
5732
+
5733
+ Use it when the superuser password is lost (Hostinger never stores it), when it leaked and
5734
+ must be rotated, or to add another superuser with a different email. Returns 404 when the
5735
+ website has no PocketBase backend; create one first. App user accounts are managed through
5736
+ the PocketBase REST API, not here.
5737
+
5738
+ `superuser_password` is optional: leave it out to get a strong generated password, or send
5739
+ your own (10-128 characters). The response returns it in `superuser_password` once and
5740
+ Hostinger never stores it, so save it in your app secrets right away, then authenticate
5741
+ again with `pb.collection('_superusers').authWithPassword`. `superuser_email` defaults to
5742
+ the email of the website owner.
5743
+
5744
+ PocketBase is rolling out gradually: an account without access yet gets 422.
5745
+ */
5746
+ "hosting_pocketbase_set-superuser": {
5747
+ params: {
5748
+ /**
5749
+ * username parameter
5750
+ */
5751
+ username: string;
5752
+ /**
5753
+ * Domain name
5754
+ */
5755
+ domain: string;
5756
+ /**
5757
+ * Email of the superuser to create or update. Defaults to the email of the website owner.
5758
+ */
5759
+ superuser_email?: string;
5760
+ /**
5761
+ * New password of the PocketBase superuser, 10-128 characters. Leave it out to have a strong
5762
+ one generated. Either way it is returned once in the response and never stored.
5763
+ */
5764
+ superuser_password?: string;
5765
+ };
5766
+ response: any; // Response structure will depend on the API
5767
+ };
5768
+
5590
5769
  /**
5591
5770
  * Returns a paginated list of redirects configured for the selected website.
5592
5771
  */
@@ -10412,9 +10591,11 @@ Send `type: headless` to turn a headless website (for example one created by
10412
10591
  `hosting_websites_create` with `type: headless_empty`) into a headless WordPress
10413
10592
  website: WordPress is installed into the `cms` directory with the Hostinger headless
10414
10593
  MU plugin and the website is marked as a headless WordPress website. `directory` is
10415
- not allowed with it. The target website must already be headless: the headless
10416
- install rewrites the root `.htaccess`, so on any other website the request is
10417
- rejected with 422.
10594
+ not allowed with it. The target website must be an empty headless website
10595
+ (`headless_empty`): the headless install rewrites the root `.htaccess`, so any other
10596
+ website, including a headless website that already has WordPress or a PocketBase
10597
+ backend, is rejected with 422. To replace a PocketBase backend with WordPress, delete
10598
+ it first with `Delete PocketBase backend`.
10418
10599
 
10419
10600
  Call GET /api/hosting/v1/wordpress/installations (`wordpress_installations_list`)
10420
10601
  filtered by username and domain before proceeding to check whether WordPress is
@@ -10449,7 +10630,7 @@ unless `database.name` is an existing database on the account.
10449
10630
  */
10450
10631
  language?: string;
10451
10632
  /**
10452
- * Installation kind; `default` when omitted. `headless` installs WordPress into the `cms` directory with the Hostinger headless MU plugin and marks the website as a headless WordPress website. Accepted only for a website that is already headless, e.g. one created by `POST /api/hosting/v1/orders/{order_id}/onboardings` (`hosting_websites_create`) with `type: headless_empty`; any other website is rejected with 422.
10633
+ * Installation kind; `default` when omitted. `headless` installs WordPress into the `cms` directory with the Hostinger headless MU plugin and marks the website as a headless WordPress website. Accepted only for an empty headless website, e.g. one created by `POST /api/hosting/v1/orders/{order_id}/onboardings` (`hosting_websites_create`) with `type: headless_empty`; any other website, including a headless website that already has WordPress or a PocketBase backend, is rejected with 422.
10453
10634
  */
10454
10635
  type?: string;
10455
10636
  /**