hostinger-api-mcp 3.28.6 → 3.29.0

package/CHANGELOG.md

@@ -4,6 +4,13 @@ Generated at release time from the diff between the previous and current
 build. Tool changes are listed individually; everything else is summarised
 by area.
 
+## v3.29.0 — 2026-11-05
+
+### Also in this release
+
+- Bundled agent skills: 12 files
+- Other files: `src/core/skills.js`, `src/core/skills.ts`
+
 ## v3.28.6 — 2026-11-05
 
 ### Also in this release

package/gemini-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "hostinger-api-mcp",
-  "version": "3.28.6",
+  "version": "3.29.0",
   "description": "Hostinger API — manage domains, DNS, hosting, VPS, billing and more from Gemini CLI.",
   "mcpServers": {
     "hostinger": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hostinger-api-mcp",
-  "version": "3.28.6",
+  "version": "3.29.0",
   "mcpName": "io.github.hostinger/hostinger-api-mcp",
   "description": "MCP server for Hostinger API",
   "repository": {

package/server.json

@@ -17,12 +17,12 @@
     "url": "https://github.com/hostinger/api-mcp-server",
     "source": "github"
   },
-  "version": "3.28.6",
+  "version": "3.29.0",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "@hostinger/mcp",
-      "version": "3.28.6",
+      "version": "3.29.0",
       "transport": {
         "type": "stdio"
       },

package/skills/headless/SKILL.md

@@ -239,6 +239,7 @@ took from it.
 | `brief.md` | refine | refined brief, audience, tone, pages, must-haves |
 | `site.json` | provision | chosen backend, username, install id, all URLs |
 | `content-model.md` | content model | entities, fields, pages, navigation |
+| `content.json` | content model (WordPress) | the drafted content `push-content.mjs` pushes |
 | `design.md` (+ `brand/` logo files) | design | chosen design direction: tokens, type, logo, components, per-page composition, accessibility |
 | `src/` | frontend | the website source implementing `design.md`; framework choice is recorded in `state.json → frontend` |
 | `deploy.json` | deploy | build id, deployed at, live URLs |

package/skills/headless/VERSION

@@ -1,3 +1,3 @@
-version=3.28.6
-commit=3ecd304d96fb
+version=3.29.0
+commit=c4c3f98adbe2
 built=2026-11-05

package/skills/headless/hostinger-mcp.mjs

@@ -0,0 +1,88 @@
+// The local Hostinger MCP server (the management API), spoken to over newline-delimited JSON-RPC on
+// stdio. It reuses the sign-in from the connect step. Shared by wait.mjs and push-content.mjs.
+
+import { spawn } from 'node:child_process';
+import { homedir } from 'node:os';
+
+// ── platform-safe binary names (npm/npx are .cmd on Windows), as in connect/bootstrap.mjs ──────────
+const isWin = process.platform === 'win32';
+const bin = (name) => (isWin ? `${name}.cmd` : name);
+const MCP = [bin('npx'), '-y', '--package=@hostinger/mcp@latest', 'hostinger-api-mcp'];
+// Node >= 18.20.2 / 20.12.2 refuses to spawn a .cmd/.bat without a shell
+// (CVE-2024-27980), so npx.cmd needs shell:true on Windows. Our args are all
+// fixed literals, so enabling the shell introduces no injection risk.
+const spawnShell = isWin;
+
+// One server per script run. Once it dies every pending and later call rejects, so the caller ends with
+// exit 2 rather than hanging.
+export function connect(clientName) {
+  const child = spawn(MCP[0], MCP.slice(1), { stdio: ['pipe', 'pipe', 'pipe'], shell: spawnShell, cwd: homedir() });
+  const pending = new Map();
+  let buffer = '';
+  let diag = '';
+  let dead = null;
+  let nextId = 0;
+  const die = (reason) => {
+    dead ??= new Error(`the Hostinger MCP server stopped (${reason}): ${diag.trim().slice(-500)}`);
+    for (const { reject } of pending.values()) reject(dead);
+    pending.clear();
+  };
+  child.on('error', (e) => die(e.message));
+  // 'close' comes after stderr is drained, so the reason is in diag. A write to a dying server fails
+  // with EPIPE before that; 'close' still follows, so the EPIPE itself is ignored.
+  child.on('close', (code) => die(`exit code ${code}`));
+  child.stdin.on('error', () => {});
+  child.stderr.on('data', (chunk) => (diag = (diag + chunk).slice(-2000)));
+  child.stdout.on('data', (chunk) => {
+    buffer += chunk;
+    let i;
+    while ((i = buffer.indexOf('\n')) >= 0) {
+      const line = buffer.slice(0, i);
+      buffer = buffer.slice(i + 1);
+      try {
+        const message = JSON.parse(line);
+        pending.get(message.id)?.resolve(message);
+        pending.delete(message.id);
+      } catch {
+        /* not a JSON-RPC line */
+      }
+    }
+  });
+  // A call can stall on a live server (a stuck upstream request), so each one has its own deadline; past
+  // it, it answers like an error reply. A stalled start ends the run. The start gets longer: a cold `npx`
+  // fetch of the server takes 13-40 s on an idle machine and over 60 s on a busy one.
+  const rpc = (method, params, seconds = 60) =>
+    new Promise((resolve, reject) => {
+      if (dead) return reject(dead);
+      const id = (nextId += 1);
+      const timer = setTimeout(() => {
+        pending.delete(id);
+        resolve({ error: { message: `no reply to ${method} in ${seconds} s` } });
+      }, seconds * 1000);
+      const settle = (fn) => (value) => {
+        clearTimeout(timer);
+        fn(value);
+      };
+      pending.set(id, { resolve: settle(resolve), reject: settle(reject) });
+      child.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id, method, params })}\n`);
+    });
+  const ready = rpc('initialize', { protocolVersion: '2025-06-18', capabilities: {}, clientInfo: { name: clientName, version: '1' } }, 180)
+    .then((reply) => {
+      if (reply.error) throw new Error(`the Hostinger MCP server didn't start: ${reply.error.message}`);
+      child.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', method: 'notifications/initialized' })}\n`);
+    });
+  // Runs one API operation: { data } on success, else { error, status } with the HTTP status the server
+  // keeps in its error text (NaN when there is none).
+  const execute = async (operation, params) => {
+    await ready;
+    const reply = await rpc('tools/call', { name: 'execute', arguments: { operation, params } });
+    const text = reply.result?.content?.[0]?.text ?? reply.error?.message ?? 'unknown error';
+    if (reply.error || reply.result?.isError) return { error: text.slice(0, 300), status: Number(text.match(/HTTP (\d{3})/)?.[1]) };
+    try {
+      return { data: JSON.parse(text) };
+    } catch {
+      return { error: text.slice(0, 300), status: NaN };
+    }
+  };
+  return { execute, close: () => child.kill() };
+}