@hostinger/mcp 3.1.0 → 3.2.1

package/src/core/runtime.ts

@@ -23,6 +23,8 @@ import axios,{ AxiosRequestConfig, AxiosError, AxiosResponse } from "axios";
 import * as tus from "tus-js-client";
 import fs from "fs";
 import path from "path";
+import os from "os";
+import { Zip, ZipDeflate } from "fflate";
 import { META_TOOLS, searchOperations, renderSearch, findOperation, runSteps } from "./catalog.js";
 import type { CatalogOperation } from "./catalog.js";
 
@@ -35,6 +37,7 @@ interface OpenApiTool extends Tool {
   path: string;
   security: unknown[];
   custom?: boolean;
+  hidden?: boolean;
   group?: string;
   topic?: string;
   handlerMethod?: string;
@@ -94,7 +97,7 @@ interface Skill { uri: string; frontmatter: Record<string, unknown>; resources:
 
 /**
  * MCP Server for Hostinger API
- * Generated from OpenAPI spec version 2.1.0
+ * Generated from OpenAPI spec version 2.1.1
  */
 class MCPServer {
   private readonly name: string;
@@ -303,6 +306,9 @@ class MCPServer {
   private async executeOperation(operation: unknown, params: unknown): Promise<any> {
     const tool = findOperation(this.operations, operation, params);
     const input = params as Record<string, any>;
+    if (tool.hidden) {
+      this.log('warning', `Operation ${tool.name} is hidden from search and will be removed in a future release`);
+    }
     this.log('info', `Executing operation: ${tool.name}`);
     return tool.custom
       ? this.executeCustomTool(tool, input)
@@ -323,10 +329,10 @@ class MCPServer {
 
   private async executeCustomTool(tool: OpenApiTool, params: Record<string, any>): Promise<any> {
     switch (tool.name) {
-      case 'agency-hosting_deploy-node-static-website':
-        return await this.handleNodeStaticDeploy(params);
-      case 'agency-hosting_deploy-php-application':
-        return await this.handlePhpAppDeploy(params);
+      case 'hosting_deploy':
+        return await this.handleHostingDeploy(params);
+      case 'hosting_get-deployment':
+        return await this.handleHostingGetDeployment(params);
       case 'hosting_import-wordpress-website':
         return await this.handleWordpressWebsiteImport(params);
       case 'hosting_deploy-wordpress-plugin':
@@ -341,119 +347,71 @@ class MCPServer {
         return await this.handleListJavascriptDeployments(params);
       case 'hosting_show-js-deployment-logs':
         return await this.handleShowJsDeploymentLogs(params);
+      case 'agency-hosting_deploy-node-static-website':
+        return await this.handleNodeStaticDeploy(params);
+      case 'agency-hosting_deploy-php-application':
+        return await this.handlePhpAppDeploy(params);
       default:
         throw new Error(`Unknown custom tool: ${tool.name}`);
     }
   }
 
-  private agencyHosting_normalizePath(pathString: string): string {
+  private normalizePath(pathString: string): string {
     return pathString.replace(/\\/g, '/');
   }
 
-  private agencyHosting_generateUploadDir(): string {
-    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
-    let result = '';
-    for (let i = 0; i < 12; i++) {
-      result += chars.charAt(Math.floor(Math.random() * chars.length));
-    }
-    return result;
-  }
-
-  private agencyHosting_validateRequiredParams(params: Record<string, any>): void {
-    const { domain, archivePath, removeArchive } = params;
-
-    if (!domain || typeof domain !== 'string') {
-      throw new Error('domain is required and must be a string');
-    }
-
-    if (!archivePath || typeof archivePath !== 'string') {
-      throw new Error('archivePath is required and must be a string');
-    }
-
-    if (removeArchive !== undefined && typeof removeArchive !== 'boolean') {
-      throw new Error('removeArchive must be a boolean if provided');
-    }
-  }
-
-  private agencyHosting_validateArchiveFile(archivePath: string): void {
-    if (!fs.existsSync(archivePath)) {
-      throw new Error(`Archive file not found: ${archivePath}`);
-    }
-
-    const archiveStats = fs.statSync(archivePath);
-    if (!archiveStats.isFile()) {
-      throw new Error(`Archive path is not a file: ${archivePath}`);
-    }
-  }
-
-  private agencyHosting_removeArchive(archivePath: string, removeArchive: boolean): boolean {
-    if (!removeArchive) {
-      return false;
-    }
-
-    try {
-      this.log('info', `Removing archive file: ${archivePath}`);
-      fs.unlinkSync(archivePath);
-      this.log('info', `Successfully removed archive file: ${archivePath}`);
-      return true;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      this.log('error', `Failed to remove archive file: ${errorMessage}`);
-      return false;
+  // The path becomes part of a URL, where a . or .. segment resolves outside its directory. Separators are
+  // normalized first, because a backslash in a file name on Linux or macOS turns into one.
+  private assertSafeUploadPath(relativePath: string): void {
+    const segments = this.normalizePath(relativePath).split('/');
+    if (segments.some((segment: string) => segment === '' || segment === '.' || segment === '..')) {
+      throw new Error('Unsafe upload path: ' + relativePath);
     }
   }
 
-  private async agencyHosting_resolveWebsiteUid(domain: string): Promise<string> {
+  private async resolveUsername(domain: string): Promise<string> {
     const baseUrl = this.baseUrl.endsWith("/") ? this.baseUrl : `${this.baseUrl}/`;
-    const perPage = 100;
-
+    const url = new URL(`api/hosting/v1/websites?domain=${encodeURIComponent(domain)}`, baseUrl).toString();
+    
     try {
       const bearerToken = await this.getAuthToken();
-      let page = 1;
-      let total = 0;
-
-      do {
-        const url = new URL(
-          `api/agency-hosting/v1/domains?page=${page}&per_page=${perPage}`,
-          baseUrl
-        ).toString();
-
-        const config: AxiosRequestConfig = {
-          method: 'get',
-          url,
-          headers: {
-            ...this.headers,
-            'Authorization': `Bearer ${bearerToken}`
-          },
-          timeout: 60000, // 60s
-          validateStatus: function (status: number): boolean {
-            return status < 500;
-          }
-        };
-
-        const response = await axios(config);
-
-        if (response.status !== 200) {
-          throw new Error(`API returned status ${response.status}: ${JSON.stringify(response.data)}`);
-        }
-
-        const domains = response.data?.data ?? [];
-        const match = domains.find((item: any) => item.fqdn === domain);
-        if (match?.website_uid) {
-          this.log('info', `Resolved website UID: ${match.website_uid} for domain: ${domain}`);
-          return match.website_uid;
+      
+      const config: AxiosRequestConfig = {
+        method: 'get',
+        url,
+        headers: {
+          ...this.headers,
+          'Authorization': `Bearer ${bearerToken}`
+        },
+        timeout: 60000, // 60s
+        validateStatus: function (status: number): boolean {
+          return status < 500;
         }
-
-        total = response.data?.meta?.total ?? domains.length;
-        page++;
-      } while ((page - 1) * perPage < total);
-
-      throw new Error(`No Agency Plan website found for domain: ${domain}`);
-
+      };
+      
+      const response = await axios(config);
+      
+      if (response.status !== 200) {
+        throw new Error(`API returned status ${response.status}: ${JSON.stringify(response.data)}`);
+      }
+      
+      const websites = response.data?.data;
+      if (!websites || websites.length === 0) {
+        throw new Error(`No website found for domain: ${domain}`);
+      }
+      
+      const username = websites[0].username;
+      if (!username) {
+        throw new Error(`Username not found in website data for domain: ${domain}`);
+      }
+      
+      this.log('info', `Resolved username: ${username} for domain: ${domain}`);
+      return username;
+      
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      this.log('error', `Failed to resolve website UID for domain ${domain}: ${errorMessage}`);
-
+      this.log('error', `Failed to resolve username for domain ${domain}: ${errorMessage}`);
+      
       if (axios.isAxiosError(error)) {
         const responseData = error.response?.data;
         const responseStatus = error.response?.status;
@@ -462,16 +420,14 @@ class MCPServer {
           data: typeof responseData === 'object' ? JSON.stringify(responseData) : responseData
         });
       }
-
+      
       throw error;
     }
   }
 
-  private async agencyHosting_fetchUploadCredentials(
-    websiteUid: string
-  ): Promise<{ url: string; auth_key: string; rest_auth_key: string }> {
+  private async fetchUploadCredentials(username: string, domain: string): Promise<{ uploadUrl: string; authRestToken: string; authToken: string }> {
     const baseUrl = this.baseUrl.endsWith("/") ? this.baseUrl : `${this.baseUrl}/`;
-    const url = new URL(`api/agency-hosting/v1/websites/${websiteUid}/files/upload-urls`, baseUrl).toString();
+    const url = new URL('api/hosting/v1/files/upload-urls', baseUrl).toString();
 
     try {
       const bearerToken = await this.getAuthToken();
@@ -484,6 +440,10 @@ class MCPServer {
           'Authorization': `Bearer ${bearerToken}`,
           'Content-Type': 'application/json'
         },
+        data: {
+          username,
+          domain
+        },
         timeout: 60000, // 60s
         validateStatus: function (status: number): boolean {
           return status < 500;
@@ -515,20 +475,23 @@ class MCPServer {
     }
   }
 
-  private async agencyHosting_uploadFile(
-    filePath: string,
-    relativePath: string,
-    uploadUrl: string,
-    authRestToken: string,
+  private async uploadFile(
+    filePath: string, 
+    relativePath: string, 
+    uploadUrl: string, 
+    authRestToken: string, 
     authToken: string
   ): Promise<{ url: string; filename: string }> {
     return new Promise(async (resolve, reject) => {
       try {
         const stats = fs.statSync(filePath);
         const fileStream = fs.createReadStream(filePath);
-
+        
+        this.assertSafeUploadPath(relativePath);
         const cleanUploadUrl = uploadUrl.replace(new RegExp('/$'), '');
-        const normalizedPath = this.agencyHosting_normalizePath(relativePath);
+        // The path is part of a URL: encode each segment so a #, ? or % in a file name is not read as
+        // a fragment, a query or an escape, and keep the / separators.
+        const normalizedPath = this.normalizePath(relativePath).split('/').map((segment: string) => encodeURIComponent(segment)).join('/');
         const uploadUrlWithFile = `${cleanUploadUrl}/${normalizedPath}?override=true`;
 
         const requestHeaders: Record<string, string> = {
@@ -549,13 +512,13 @@ class MCPServer {
           });
         } catch (error) {
           const errorMessage = error instanceof Error ? error.message : String(error);
-
+          
           if (axios.isAxiosError(error)) {
             const responseData = error.response?.data;
             const responseStatus = error.response?.status;
             const responseHeaders = error.response?.headers;
             const responseText = typeof responseData === 'object' ? JSON.stringify(responseData) : responseData;
-
+            
             this.log('error', 'Pre-upload POST request failed - Full Response Details:', {
               status: responseStatus,
               headers: responseHeaders,
@@ -606,292 +569,748 @@ class MCPServer {
     });
   }
 
-  private async agencyHosting_deployNodeStatic_triggerBuildAssets(websiteUid: string, archivePath: string): Promise<any> {
-    const baseUrl = this.baseUrl.endsWith("/") ? this.baseUrl : `${this.baseUrl}/`;
-    const url = new URL(`api/agency-hosting/v1/websites/${websiteUid}/build-assets`, baseUrl).toString();
+  // Run a catalog operation by name through the runtime's own request code (auth,
+  // path parameters, API errors). Hidden operations are still in the catalog, and
+  // calling them here does not log the deprecation warning that execute does.
+  private async callOperation(name: string, params: Record<string, any>): Promise<any> {
+    const tool = this.operations.get(name);
+    if (!tool) {
+      throw new Error(`Operation ${name} is not available in this server`);
+    }
+    return this.executeApiCall(tool, params);
+  }
 
-    try {
-      const bearerToken = await this.getAuthToken();
+  // The website for a domain, matched exactly (the list endpoint filters by substring).
+  private async findWebsite(domain: string): Promise<any> {
+    const response = await this.callOperation('hosting_websites_list', { domain });
+    const sites = response && Array.isArray(response.data) ? response.data : [];
+    const site = sites.find((website: any) => website.domain && website.domain.toLowerCase() === domain.toLowerCase());
+    if (!site) {
+      throw new Error('No website found for domain: ' + domain);
+    }
+    return site;
+  }
 
-      const config: AxiosRequestConfig = {
-        method: 'post',
-        url,
-        headers: {
-          ...this.headers,
-          'Authorization': `Bearer ${bearerToken}`,
-          'Content-Type': 'application/json'
-        },
-        data: {
-          archive_path: archivePath
-        },
-        timeout: 60000,
-        validateStatus: function (status: number): boolean {
-          return status < 500;
-        }
-      };
+  private hosting_deploy_types = ['static', 'nodejs', 'wordpress-site', 'wordpress-plugin', 'wordpress-theme'];
 
-      const response = await axios(config);
+  // A package.json that depends on one of these is an app with a server, not dev tooling.
+  private hosting_deploy_serverDependencies = ['express', 'fastify', 'koa', 'hono', 'next', 'nuxt', '@nestjs/core', '@remix-run/node', '@sveltejs/kit', 'astro'];
 
-      if (response.status < 200 || response.status >= 300) {
-        throw new Error(`API returned status ${response.status}: ${JSON.stringify(response.data)}`);
-      }
+  // WordPress reads plugin and theme headers from the first 8 KB of a file.
+  private hosting_deploy_head(file: string): string {
+    const fd = fs.openSync(file, 'r');
+    try {
+      const buffer = Buffer.alloc(8192);
+      const read = fs.readSync(fd, buffer, 0, 8192, 0);
+      return buffer.toString('utf8', 0, read).toLowerCase();
+    } finally {
+      fs.closeSync(fd);
+    }
+  }
 
-      this.log('info', `Successfully triggered build for website ${websiteUid}`);
-      return response.data;
+  // What a directory is, from files in its top level. WordPress signals win over package.json,
+  // because plugins and themes routinely carry one for their assets. Two WordPress signals at
+  // once are ambiguous and need an explicit type.
+  private hosting_deploy_detectType(dir: string): string {
+    if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) {
+      throw new Error('Directory not found: ' + dir);
+    }
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    const hasFile = (name: string): boolean => entries.some((entry) => entry.isFile() && entry.name === name);
 
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      this.log('error', `Failed to trigger build: ${errorMessage}`);
+    const wordpress: string[] = [];
+    if (entries.some((entry) => entry.isFile() && entry.name.endsWith('.php') && this.hosting_deploy_head(path.join(dir, entry.name)).includes('plugin name:'))) {
+      wordpress.push('wordpress-plugin');
+    }
+    if (hasFile('style.css') && this.hosting_deploy_head(path.join(dir, 'style.css')).includes('theme name:')) {
+      wordpress.push('wordpress-theme');
+    }
+    if (hasFile('wp-config.php') || entries.some((entry) => entry.isDirectory() && entry.name === 'wp-content')) {
+      wordpress.push('wordpress-site');
+    }
+    if (wordpress.length > 1) {
+      throw new Error('Ambiguous directory: it looks like ' + wordpress.join(' and ') + '. Pass type to choose.');
+    }
+    if (wordpress.length === 1) {
+      return wordpress[0];
+    }
 
-      if (axios.isAxiosError(error)) {
-        const responseData = error.response?.data;
-        const responseStatus = error.response?.status;
-        this.log('error', 'API Error Details:', {
-          status: responseStatus,
-          data: typeof responseData === 'object' ? JSON.stringify(responseData) : responseData
-        });
+    let pkg: any = null;
+    const manifest = path.join(dir, 'package.json');
+    if (fs.existsSync(manifest)) {
+      try {
+        pkg = JSON.parse(fs.readFileSync(manifest, 'utf8'));
+      } catch (error) {
+        throw new Error('package.json could not be read (' + (error instanceof Error ? error.message : String(error)) + '): fix it, or pass type to skip detection');
+      }
+    }
+    if (pkg) {
+      const dependencies = pkg.dependencies || {};
+      const hasServer = this.hosting_deploy_serverDependencies.some((name) => dependencies[name] !== undefined);
+      if ((pkg.scripts && (pkg.scripts.build || pkg.scripts.start)) || hasServer) {
+        return 'nodejs';
       }
-
-      throw error;
     }
+    return 'static';
   }
 
-  private async handleNodeStaticDeploy(params: Record<string, any>): Promise<any> {
-    const { domain, archivePath, removeArchive = true } = params;
-
-    this.agencyHosting_validateRequiredParams(params);
-    this.agencyHosting_validateArchiveFile(archivePath);
-
-    this.log('info', `Resolving website UID from domain: ${domain}`);
-    const websiteUid = await this.agencyHosting_resolveWebsiteUid(domain);
-
-    this.log('info', `Starting archive upload for ${domain}`);
-
-    let uploadCredentials: any;
+  // The explicit type if given, else detected from a directory. Archives cannot be inspected.
+  private hosting_deploy_resolveType(params: Record<string, any>): string {
+    const { path: sourcePath, type, databaseDump } = params;
+    let stats: fs.Stats;
     try {
-      uploadCredentials = await this.agencyHosting_fetchUploadCredentials(websiteUid);
+      stats = fs.statSync(sourcePath);
     } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      throw new Error(`Failed to fetch upload credentials: ${errorMessage}`);
+      throw new Error('Path not found: ' + sourcePath);
     }
 
-    const { url: uploadUrl, auth_key: authToken, rest_auth_key: authRestToken } = uploadCredentials;
+    if (type !== undefined && !this.hosting_deploy_types.includes(type)) {
+      throw new Error('type must be one of: ' + this.hosting_deploy_types.join(', '));
+    }
+    let resolved = type;
+    if (resolved === undefined) {
+      if (!stats.isDirectory()) {
+        throw new Error('The path is an archive, which cannot be inspected: pass type (static, nodejs or wordpress-site), or pass the directory to detect it');
+      }
+      resolved = this.hosting_deploy_detectType(sourcePath);
+    }
+    if ((resolved === 'wordpress-plugin' || resolved === 'wordpress-theme') && !stats.isDirectory()) {
+      throw new Error('A ' + (resolved === 'wordpress-plugin' ? 'plugin' : 'theme') + ' deploy needs a directory, not a file');
+    }
+    if (resolved === 'wordpress-site' && !databaseDump) {
+      throw new Error('databaseDump (path to a .sql file) is required to import a WordPress site');
+    }
+    return resolved;
+  }
 
-    if (!uploadUrl || !authToken || !authRestToken) {
-      throw new Error('Invalid upload credentials received from API');
+  // A WordPress slug from a directory name: lower case letters, digits, "-" and "_".
+  private hosting_deploy_slug(dir: string): string {
+    const base = path.basename(dir);
+    const slug = base.toLowerCase().replace(/[^a-z0-9_-]+/g, '-').replace(/^-+|-+$/g, '');
+    if (!slug) {
+      throw new Error('Cannot derive a slug from "' + base + '"; pass slug');
     }
+    return slug;
+  }
 
-    const archiveBasename = path.basename(archivePath);
-    const uploadDir = `.h5g/${this.agencyHosting_generateUploadDir()}`;
-    let uploadResult: any;
-    try {
-      uploadResult = await this.agencyHosting_uploadFile(
-        archivePath,
-        `${uploadDir}/${archiveBasename}`,
-        uploadUrl,
-        authRestToken,
-        authToken
-      );
+  // .env and .env.* hold secrets, and one in a document root can be fetched over HTTP; the platform
+  // takes variables from its own settings, so they are never packed. Examples are kept.
+  private hosting_deploy_isEnvFile(name: string): boolean {
+    return name === '.env' || (name.startsWith('.env.') && !['.env.example', '.env.sample', '.env.template', '.env.dist'].includes(name));
+  }
 
-      this.log('info', `Successfully uploaded archive: ${archiveBasename}`);
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      throw new Error(`Failed to upload archive: ${errorMessage}`);
+  // The files to ship, as sorted forward-slash paths relative to dir, and the .env files left out.
+  // node_modules, .git and OS junk are skipped; symlinks are not followed. .gitignore is not read:
+  // keep build output out of the directory.
+  // exclude is a file that is uploaded on its own (the database dump) and must not also travel inside
+  // the archive, where extracting it would leave a second, downloadable copy.
+  private hosting_deploy_listFiles(dir: string, exclude?: string): { files: string[]; skipped: string[] } {
+    const files: string[] = [];
+    const skipped: string[] = [];
+    const walk = (relativeDir: string): void => {
+      for (const entry of fs.readdirSync(path.join(dir, relativeDir), { withFileTypes: true })) {
+        if (entry.isSymbolicLink()) {
+          continue;
+        }
+        const relativePath = relativeDir ? relativeDir + '/' + entry.name : entry.name;
+        if (entry.isDirectory()) {
+          if (entry.name !== 'node_modules' && entry.name !== '.git') {
+            walk(relativePath);
+          }
+        } else if (entry.isFile() && entry.name !== '.DS_Store' && path.resolve(dir, relativePath) !== exclude) {
+          if (this.hosting_deploy_isEnvFile(entry.name)) {
+            skipped.push(relativePath);
+          } else {
+            files.push(relativePath);
+          }
+        }
+      }
+    };
+    walk('');
+    return { files: files.sort(), skipped: skipped.sort() };
+  }
+
+  // Adds what was left out to a result, so it is never silent.
+  private hosting_deploy_withSkipped(result: any, skipped: string[]): any {
+    if (skipped.length === 0) {
+      return result;
     }
+    return {
+      ...result,
+      skippedFiles: skipped,
+      skippedNote: 'These .env files were not uploaded. Set their values with hosting_nodejs_replace-environment-variables.',
+    };
+  }
 
-    let deployResult: any;
+  private async hosting_deploy_createZip(dir: string, files: string[], dest: string): Promise<void> {
+    const out = fs.createWriteStream(dest);
+    const finished = new Promise<void>((resolve, reject) => {
+      out.on('finish', () => resolve());
+      out.on('error', reject);
+    });
+    // The error is reported by the final await; this keeps an early one from being an unhandled rejection.
+    finished.catch(() => {});
+    const zip = new Zip((error, chunk, final) => {
+      if (error) {
+        out.destroy(error);
+        return;
+      }
+      out.write(chunk);
+      if (final) {
+        out.end();
+      }
+    });
+    // When the output stream is full, stop reading and compressing until it drains, so a large site cannot
+    // pile up in memory; a write error ends the wait.
+    const drained = async (): Promise<void> => {
+      if (out.writableNeedDrain) {
+        await Promise.race([new Promise<void>((resolve) => out.once('drain', () => resolve())), finished]);
+      }
+    };
     try {
-      this.log('info', `Triggering build for ${domain}`);
-      deployResult = await this.agencyHosting_deployNodeStatic_triggerBuildAssets(websiteUid, uploadDir);
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      this.log('error', `Failed to trigger build: ${errorMessage}`);
-      const archiveRemoved = this.agencyHosting_removeArchive(archivePath, removeArchive);
-
-      return {
-        upload: {
-          status: 'success',
-          data: {
-            filename: uploadResult.filename
+      for (const relativePath of files) {
+        const entry = new ZipDeflate(relativePath, { level: 6 });
+        zip.add(entry);
+        for await (const chunk of fs.createReadStream(path.join(dir, relativePath))) {
+          entry.push(chunk);
+          await drained();
+          if (out.destroyed) {
+            break;
           }
-        },
-        deploy: {
-          status: 'error',
-          error: errorMessage
-        },
-        removeArchive: {
-          status: archiveRemoved ? 'success' : 'skipped'
         }
-      };
-    }
-
-    const archiveRemoved = this.agencyHosting_removeArchive(archivePath, removeArchive);
-
-    return {
-      upload: {
-        status: 'success',
-        data: {
-          filename: uploadResult.filename
+        if (out.destroyed) {
+          break;
         }
-      },
-      deploy: {
-        status: 'success',
-        data: deployResult
-      },
-      removeArchive: {
-        status: archiveRemoved ? 'success' : 'skipped'
+        entry.push(new Uint8Array(0), true);
+        await drained();
       }
+      zip.end();
+    } catch (error) {
+      out.destroy(error as Error);
+    }
+    await finished;
+  }
+
+  // The start-build fields: explicit overrides (the tool's camelCase params) beat base, which is
+  // the settings detected from an archive or stored for the site. Only the framework is required.
+  // An app that runs straight from source (plain-JavaScript Express) has no build script or output
+  // directory, and the API stores them as null, so a missing one is sent as null. Detection supplies
+  // the build script but only guesses a root-level entry file, so a compiled app (TypeScript) must
+  // pass entryFile.
+  // storedSettings tells base apart: settings stored for the site (Git deploy) belong to whatever
+  // framework it ran before, so a different appType starts from a clean build step, while settings
+  // detected from the project itself (archive deploy) are always right to keep.
+  private hosting_deploy_nodeSettings(base: Record<string, any> | null, params: Record<string, any>, storedSettings: boolean): Record<string, any> {
+    const given = base || {};
+    const appType = params.appType ?? given.app_type;
+    const sameFramework = !storedSettings || params.appType === undefined || params.appType === given.app_type;
+    const stored = sameFramework ? given : { node_version: given.node_version, root_directory: given.root_directory, package_manager: given.package_manager };
+    if (appType === undefined || appType === null) {
+      throw new Error("Missing Node.js build setting: appType. Pass it to hosting_deploy, with outputDirectory and buildScript when the app has a build step; read them from the project's package.json.");
+    }
+    const optional: Record<string, any> = {
+      entry_file: params.entryFile ?? stored.entry_file,
+      package_manager: params.packageManager ?? stored.package_manager,
+    };
+    return {
+      node_version: params.nodeVersion ?? stored.node_version ?? 22,
+      app_type: appType,
+      root_directory: params.rootDirectory ?? stored.root_directory ?? '.',
+      output_directory: params.outputDirectory ?? stored.output_directory ?? null,
+      build_script: params.buildScript ?? stored.build_script ?? null,
+      ...Object.fromEntries(Object.entries(optional).filter(([, value]) => value !== undefined && value !== null)),
     };
   }
 
-  private async agencyHosting_deployPhpApp_triggerImportArchive(websiteUid: string, archiveName: string): Promise<any> {
-    const baseUrl = this.baseUrl.endsWith("/") ? this.baseUrl : `${this.baseUrl}/`;
-    const url = new URL(`api/agency-hosting/v1/websites/${websiteUid}/files/import-archive`, baseUrl).toString();
+  private hosting_deploy_hasNodeOverrides(params: Record<string, any>): boolean {
+    return ['nodeVersion', 'appType', 'rootDirectory', 'outputDirectory', 'buildScript', 'entryFile', 'packageManager'].some((name) => params[name] !== undefined);
+  }
 
-    try {
-      const bearerToken = await this.getAuthToken();
+  // The folder of the site a static Git deploy goes into, as a clean relative path ('' is the document root).
+  // Separators are normalized first, because some servers read a backslash as one: a value made of dots and
+  // backslashes, or one that starts with a drive letter, must not get past as a name.
+  private hosting_deploy_gitDirectory(git: Record<string, any>): string {
+    if (git.directory === undefined || git.directory === '') {
+      return '';
+    }
+    let directory = typeof git.directory === 'string' ? this.normalizePath(git.directory) : '';
+    while (directory.length > 1 && directory.endsWith('/')) {
+      directory = directory.slice(0, -1);
+    }
+    const driveRooted = directory.length > 1 && directory[1] === ':' && /[A-Za-z]/.test(directory[0]);
+    if (directory === '' || directory.startsWith('/') || driveRooted || directory.split('/').some((segment: string) => segment === '' || segment === '.' || segment === '..')) {
+      throw new Error('git.directory must be a relative path inside the website, without ..');
+    }
+    return directory;
+  }
 
-      const config: AxiosRequestConfig = {
-        method: 'post',
-        url,
-        headers: {
-          ...this.headers,
-          'Authorization': `Bearer ${bearerToken}`,
-          'Content-Type': 'application/json'
-        },
-        data: {
-          archive_name: archiveName
-        },
-        timeout: 60000,
-        validateStatus: function (status: number): boolean {
-          return status < 500;
-        }
-      };
+  private hosting_deploy_validate(params: Record<string, any>): void {
+    const { domain, path: sourcePath, git } = params;
 
-      const response = await axios(config);
+    if (!domain || typeof domain !== 'string') {
+      throw new Error('domain is required and must be a string');
+    }
+    if ((sourcePath === undefined) === (git === undefined)) {
+      throw new Error('Pass exactly one of path (a local directory or archive) or git ({ repository, branch })');
+    }
+    if (sourcePath !== undefined && (typeof sourcePath !== 'string' || sourcePath === '')) {
+      throw new Error('path must be a non-empty string');
+    }
+    // The slug becomes part of the remote upload path, so it cannot carry path or URL syntax.
+    if (params.slug !== undefined && !(typeof params.slug === 'string' && /^[a-z0-9_-]+$/.test(params.slug))) {
+      throw new Error('slug must contain only lower-case letters, digits, "-" and "_"');
+    }
+    if (git !== undefined && (typeof git !== 'object' || git === null || typeof git.repository !== 'string' || typeof git.branch !== 'string' || git.branch === '')) {
+      throw new Error('git must be an object with repository (owner/name) and branch');
+    }
+    // Read only now that git is known to be an object.
+    if (git !== undefined) {
+      this.hosting_deploy_gitDirectory(git);
+    }
+  }
 
-      if (response.status < 200 || response.status >= 300) {
-        throw new Error(`API returned status ${response.status}: ${JSON.stringify(response.data)}`);
+  private hosting_deploy_timestamp(): string {
+    const pad = (value: number): string => String(value).padStart(2, '0');
+    const now = new Date();
+    return String(now.getFullYear()) + pad(now.getMonth() + 1) + pad(now.getDate()) + '_' + pad(now.getHours()) + pad(now.getMinutes()) + pad(now.getSeconds());
+  }
+
+  // The WordPress deploy endpoints, called directly. hosting_deploy also runs in hostinger-hosting-mcp,
+  // whose catalog holds the hosting group only, so it cannot look these operations up.
+  private hosting_deploy_wordpressEndpoints: Record<string, string> = {
+    import: '/api/hosting/v1/accounts/{username}/websites/{domain}/wordpress/import',
+    plugin: '/api/hosting/v1/accounts/{username}/websites/{domain}/wordpress/plugins/deploy',
+    theme: '/api/hosting/v1/accounts/{username}/websites/{domain}/wordpress/themes/deploy',
+  };
+
+  private async hosting_deploy_callWordpress(kind: string, params: Record<string, any>): Promise<any> {
+    return this.executeApiCall({ name: 'wordpress_' + kind, method: 'POST', path: this.hosting_deploy_wordpressEndpoints[kind] } as any, params);
+  }
+
+  private hosting_deploy_randomSuffix(): string {
+    return Math.random().toString(36).slice(2, 10).padEnd(8, '0');
+  }
+
+  // A directory is zipped into a temp dir (removed by the caller); an archive is used as is.
+  private async hosting_deploy_prepareArchive(sourcePath: string, exclude?: string): Promise<{ archivePath: string; tempDir?: string; skipped: string[] }> {
+    const resolved = path.resolve(sourcePath);
+    if (fs.statSync(resolved).isFile()) {
+      const name = path.basename(resolved).toLowerCase();
+      const formats = ['.zip', '.tar', '.tar.gz', '.tgz', '.7z', '.gz', '.gzip'];
+      if (!formats.some((extension) => name.endsWith(extension))) {
+        throw new Error('Invalid archive format. Supported formats: zip, tar, tar.gz, tgz, 7z, gz, gzip');
       }
+      return { archivePath: resolved, skipped: [] };
+    }
 
-      this.log('info', `Successfully triggered import for website ${websiteUid}`);
-      return response.data;
+    const { files, skipped } = this.hosting_deploy_listFiles(resolved, exclude);
+    if (files.length === 0) {
+      throw new Error('No files to deploy in ' + resolved);
+    }
+    let baseName = 'site';
+    try {
+      baseName = this.hosting_deploy_slug(resolved);
+    } catch (error) {
+      // an unusable directory name only changes the archive's file name
+    }
+    // A file name made of dots and backslashes would be written into the zip as it is, where an extractor
+    // that treats backslashes as separators reads it as a path outside the site.
+    for (const file of files) {
+      this.assertSafeUploadPath(file);
+    }
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'hostinger-deploy-'));
+    const archivePath = path.join(tempDir, baseName + '_' + this.hosting_deploy_timestamp() + '.zip');
+    this.log('info', 'Packing ' + files.length + ' files from ' + resolved);
+    await this.hosting_deploy_createZip(resolved, files, archivePath);
+    return { archivePath, tempDir, skipped };
+  }
 
+  private async hosting_deploy_upload(username: string, domain: string, files: Array<{ absolutePath: string; relativePath: string }>): Promise<void> {
+    // Check every name first, so a bad one fails the deploy before anything is uploaded.
+    for (const file of files) {
+      this.assertSafeUploadPath(file.relativePath);
+    }
+    let credentials: any;
+    try {
+      credentials = await this.fetchUploadCredentials(username, domain);
     } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      this.log('error', `Failed to trigger import: ${errorMessage}`);
+      throw new Error('Failed to fetch upload credentials: ' + (error instanceof Error ? error.message : String(error)));
+    }
+    const { url: uploadUrl, auth_key: authToken, rest_auth_key: authRestToken } = credentials;
+    if (!uploadUrl || !authToken || !authRestToken) {
+      throw new Error('Invalid upload credentials received from API');
+    }
 
-      if (axios.isAxiosError(error)) {
-        const responseData = error.response?.data;
-        const responseStatus = error.response?.status;
-        this.log('error', 'API Error Details:', {
-          status: responseStatus,
-          data: typeof responseData === 'object' ? JSON.stringify(responseData) : responseData
+    for (const file of files) {
+      try {
+        await this.uploadFile(file.absolutePath, file.relativePath, uploadUrl, authRestToken, authToken);
+      } catch (error) {
+        throw new Error('Failed to upload ' + file.relativePath + ': ' + (error instanceof Error ? error.message : String(error)));
+      }
+    }
+  }
+
+  private async hosting_deploy_wordpressExtension(username: string, domain: string, type: string, params: Record<string, any>): Promise<any> {
+    const isPlugin = type === 'wordpress-plugin';
+    const directory = path.resolve(params.path);
+    const slug = params.slug !== undefined ? params.slug : this.hosting_deploy_slug(directory);
+    const { files, skipped } = this.hosting_deploy_listFiles(directory);
+    if (files.length === 0) {
+      throw new Error('No files found in directory: ' + directory);
+    }
+
+    // The files land in a fresh directory; the deploy call then installs from it.
+    const uploadDirName = slug + '-' + this.hosting_deploy_randomSuffix();
+    const remoteRoot = (isPlugin ? 'wp-content/plugins/' : 'wp-content/themes/') + uploadDirName;
+    await this.hosting_deploy_upload(username, domain, files.map((relativePath) => ({
+      absolutePath: path.join(directory, relativePath),
+      relativePath: remoteRoot + '/' + relativePath,
+    })));
+
+    if (isPlugin) {
+      await this.hosting_deploy_callWordpress('plugin', { username, domain, slug, plugin_path: uploadDirName });
+    } else {
+      await this.hosting_deploy_callWordpress('theme', { username, domain, slug, theme_path: uploadDirName, is_activated: params.activate === true });
+    }
+
+    return this.hosting_deploy_withSkipped({
+      type,
+      domain,
+      source: 'path',
+      status: 'deployed',
+      slug,
+      files: files.length,
+      ...(isPlugin ? {} : { activated: params.activate === true }),
+    }, skipped);
+  }
+
+  private async hosting_deploy_fromPath(username: string, domain: string, type: string, params: Record<string, any>): Promise<any> {
+    if (type === 'wordpress-plugin' || type === 'wordpress-theme') {
+      return this.hosting_deploy_wordpressExtension(username, domain, type, params);
+    }
+
+    const uploads: Array<{ absolutePath: string; relativePath: string }> = [];
+    let databaseDump: string | undefined;
+    if (type === 'wordpress-site') {
+      databaseDump = path.resolve(params.databaseDump);
+      if (!databaseDump.toLowerCase().endsWith('.sql')) {
+        throw new Error('databaseDump must be a .sql file');
+      }
+      if (!fs.existsSync(databaseDump)) {
+        throw new Error('Database dump not found: ' + databaseDump);
+      }
+    }
+
+    const prepared = await this.hosting_deploy_prepareArchive(params.path, databaseDump);
+    try {
+      const archiveName = path.basename(prepared.archivePath);
+      uploads.push({ absolutePath: prepared.archivePath, relativePath: archiveName });
+      if (databaseDump !== undefined) {
+        uploads.push({ absolutePath: databaseDump, relativePath: path.basename(databaseDump) });
+      }
+      await this.hosting_deploy_upload(username, domain, uploads);
+
+      if (type === 'static') {
+        const result = await this.callOperation('hosting_websites_deploy-static-site-archive', { username, domain, archive_path: archiveName });
+        return this.hosting_deploy_withSkipped({ type, domain, source: 'path', status: 'deployed', message: result?.message }, prepared.skipped);
+      }
+
+      if (type === 'wordpress-site') {
+        const result = await this.hosting_deploy_callWordpress('import', {
+          username, domain, archive_path: archiveName, sql_path: path.basename(databaseDump as string),
         });
+        return this.hosting_deploy_withSkipped({
+          type, domain, source: 'path', status: 'import_started', message: result?.message,
+          next: 'Files are extracted on the server and the site is available in a few minutes.',
+        }, prepared.skipped);
       }
 
-      throw error;
+      // nodejs: let the server detect the settings from the archive, then apply any overrides.
+      let detected: any = null;
+      let detectionError = '';
+      try {
+        detected = await this.callOperation('hosting_nodejs_build-settings-from-archive', { username, domain, archive_path: archiveName });
+      } catch (error) {
+        detectionError = error instanceof Error ? error.message : String(error);
+        this.log('warning', 'Build settings detection failed: ' + detectionError);
+      }
+      let settings: Record<string, any>;
+      try {
+        settings = this.hosting_deploy_nodeSettings(detected, params, false);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(detectionError ? message + ' (automatic detection failed: ' + detectionError + ')' : message);
+      }
+      const build = await this.callOperation('hosting_nodejs_start-build', {
+        username, domain, ...settings, source_type: 'archive', source_options: { archive_path: archiveName },
+      });
+      return this.hosting_deploy_withSkipped(this.hosting_deploy_buildStarted(type, domain, 'path', build), prepared.skipped);
+    } finally {
+      if (prepared.tempDir) {
+        fs.rmSync(prepared.tempDir, { recursive: true, force: true });
+      }
     }
   }
 
-  private async handlePhpAppDeploy(params: Record<string, any>): Promise<any> {
-    const { domain, archivePath, removeArchive = true } = params;
+  private hosting_deploy_buildStarted(type: string, domain: string, source: string, build: any): any {
+    return {
+      type,
+      domain,
+      source,
+      status: 'build_started',
+      buildUuid: build?.uuid,
+      state: build?.state,
+      next: 'The build runs on the server. Call hosting_get-deployment with this domain until the build state is completed or failed; a failed build comes back with its logs and analysis.',
+    };
+  }
 
-    this.agencyHosting_validateRequiredParams(params);
-    this.agencyHosting_validateArchiveFile(archivePath);
+  // The Git installation that can reach owner/name (GitLab owners may contain slashes).
+  private async hosting_deploy_findRepository(fullName: string): Promise<{ installationUuid: string; owner: string; repository: string }> {
+    if (!fullName.includes('/')) {
+      throw new Error('git.repository must be given as owner/name');
+    }
+    const installations = await this.callOperation('hosting_git_list-installations', { status: 'active' });
+    if (!Array.isArray(installations) || installations.length === 0) {
+      throw new Error('No active Git installation. Connect GitHub or GitLab once in hPanel (Websites, Manage, Advanced, Git), then try again.');
+    }
+    for (const installation of installations) {
+      const repositories = await this.callOperation('hosting_git_list-installation-repositories', { uuid: installation.uuid });
+      const repo = (Array.isArray(repositories) ? repositories : []).find((candidate: any) => String(candidate.full_name).toLowerCase() === fullName.toLowerCase());
+      if (repo) {
+        return { installationUuid: installation.uuid, owner: repo.owner, repository: repo.name };
+      }
+    }
+    throw new Error('Repository ' + fullName + ' was not found in your ' + installations.length + ' active Git installation(s). Check the name, or give the Git provider access to it in hPanel (Websites, Manage, Advanced, Git).');
+  }
 
-    this.log('info', `Resolving website UID from domain: ${domain}`);
-    const websiteUid = await this.agencyHosting_resolveWebsiteUid(domain);
+  // What a Git deploy is. There are no local files to look at, so guessing is dangerous: a Node.js
+  // repository deployed as a static site would publish its source and switch on push-to-deploy. The
+  // type given, the site already running Node.js, or Node.js settings in the request are clear
+  // intent; anything else has to say what it is.
+  private hosting_deploy_gitType(website: any, params: Record<string, any>): string {
+    if (params.type !== undefined) {
+      return params.type;
+    }
+    if (website.website_type === 'nodejs' || this.hosting_deploy_hasNodeOverrides(params)) {
+      return 'nodejs';
+    }
+    throw new Error("A Git deploy needs type ('static' or 'nodejs'): this site is not a Node.js site yet, and a repository's kind cannot be told without its files.");
+  }
 
-    this.log('info', `Starting archive upload for ${domain}`);
+  private async hosting_deploy_fromGit(website: any, domain: string, git: Record<string, any>, params: Record<string, any>): Promise<any> {
+    const username = website.username;
+    const type = this.hosting_deploy_gitType(website, params);
+    if (type !== 'nodejs' && type !== 'static') {
+      throw new Error('A Git deploy supports type static or nodejs, not ' + type);
+    }
+    const directory = this.hosting_deploy_gitDirectory(git);
+    if (type === 'nodejs' && directory !== '') {
+      throw new Error('git.directory is for static deploys: a Node.js build has no target folder');
+    }
+    const repo = await this.hosting_deploy_findRepository(git.repository);
 
-    let uploadCredentials: any;
+    if (type === 'static') {
+      // Saving the settings deploys the branch now and again on every push.
+      const result = await this.callOperation('hosting_git_update-auto-deployment-settings', {
+        username, domain, installation_uuid: repo.installationUuid, owner: repo.owner, repository: repo.repository, branch: git.branch, is_enabled: true,
+        ...(directory !== '' ? { directory } : {}),
+      });
+      return { type, domain, source: 'git', status: 'deployed', autoDeploy: true, message: result?.message };
+    }
+
+    // Nothing is uploaded, so there is no archive to detect from: use the settings stored for the site.
+    let stored: any = null;
     try {
-      uploadCredentials = await this.agencyHosting_fetchUploadCredentials(websiteUid);
+      stored = await this.callOperation('hosting_nodejs_build-settings', { username, domain });
     } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      throw new Error(`Failed to fetch upload credentials: ${errorMessage}`);
+      if (!(error instanceof ApiExecutionError && error.status === 404)) {
+        throw error;
+      }
+    }
+    const settings = this.hosting_deploy_nodeSettings(stored, params, true);
+    if (this.hosting_deploy_hasNodeOverrides(params)) {
+      // Later pushes build with the stored settings, not with this request: keep what was given.
+      await this.callOperation('hosting_nodejs_update-build-settings', { username, domain, ...settings });
     }
+    const build = await this.callOperation('hosting_nodejs_start-build', {
+      username, domain, ...settings, source_type: 'git',
+      source_options: { owner: repo.owner, repository: repo.repository, branch: git.branch, installation_uuid: repo.installationUuid },
+    });
+    return this.hosting_deploy_buildStarted(type, domain, 'git', build);
+  }
 
-    const { url: uploadUrl, auth_key: authToken, rest_auth_key: authRestToken } = uploadCredentials;
+  private async handleHostingDeploy(params: Record<string, any>): Promise<any> {
+    this.hosting_deploy_validate(params);
+    const { domain, git } = params;
 
-    if (!uploadUrl || !authToken || !authRestToken) {
-      throw new Error('Invalid upload credentials received from API');
+    if (git === undefined) {
+      // Local checks first, so a bad path fails before any request is made.
+      const type = this.hosting_deploy_resolveType(params);
+      const website = await this.findWebsite(domain);
+      return this.hosting_deploy_fromPath(website.username, domain, type, params);
     }
+    const website = await this.findWebsite(domain);
+    return this.hosting_deploy_fromGit(website, domain, git, params);
+  }
 
-    const archiveBasename = path.basename(archivePath);
-    let uploadResult: any;
-    try {
-      uploadResult = await this.agencyHosting_uploadFile(
-        archivePath,
-        `.h5g/${archiveBasename}`,
-        uploadUrl,
-        authRestToken,
-        authToken
-      );
+  // The failure analysis re-runs on every call and is limited to 5 a minute, so keep one request per
+  // build, stored as soon as it starts so that polls at the same moment share it.
+  private hosting_getDeployment_analyses = new Map<string, Promise<any>>();
 
-      this.log('info', `Successfully uploaded archive: ${archiveBasename}`);
+  // A failed analysis (429, outage) is remembered for a minute, so polling does not retry the
+  // rate-limited endpoint on every call; after that it is tried again.
+  private hosting_getDeployment_failures = new Map<string, { error: string; at: number }>();
+
+  // Settings that do not exist yet answer 404; that is "none", not a failure.
+  private async hosting_getDeployment_orNull(request: Promise<any>): Promise<any> {
+    try {
+      return await request;
     } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      throw new Error(`Failed to upload archive: ${errorMessage}`);
+      if (error instanceof ApiExecutionError && error.status === 404) {
+        return null;
+      }
+      throw error;
     }
+  }
 
-    let deployResult: any;
+  private async hosting_getDeployment_analysis(username: string, domain: string, uuid: string): Promise<any> {
+    const key = username + '/' + domain + '/' + uuid;
+    const failure = this.hosting_getDeployment_failures.get(key);
+    if (failure && Date.now() - failure.at < 60000) {
+      return { error: failure.error };
+    }
+    if (!this.hosting_getDeployment_analyses.has(key)) {
+      this.hosting_getDeployment_analyses.set(key, this.callOperation('hosting_nodejs_analyse-failed-build', { username, domain, uuid }));
+    }
     try {
-      this.log('info', `Triggering import for ${domain}`);
-      deployResult = await this.agencyHosting_deployPhpApp_triggerImportArchive(websiteUid, archiveBasename);
+      const analysis = await this.hosting_getDeployment_analyses.get(key);
+      this.hosting_getDeployment_failures.delete(key);
+      return analysis;
     } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      this.log('error', `Failed to trigger import: ${errorMessage}`);
-      const archiveRemoved = this.agencyHosting_removeArchive(archivePath, removeArchive);
+      // Rate limited or unavailable: report it, but do not lose the build and its logs.
+      this.hosting_getDeployment_analyses.delete(key);
+      const message = this.formatToolError(error);
+      this.hosting_getDeployment_failures.set(key, { error: message, at: Date.now() });
+      return { error: message };
+    }
+  }
+
+  private async handleHostingGetDeployment(params: Record<string, any>): Promise<any> {
+    const { domain, buildUuid, fromLine } = params;
+
+    if (!domain || typeof domain !== 'string') {
+      throw new Error('domain is required and must be a string');
+    }
+    if (buildUuid !== undefined && (typeof buildUuid !== 'string' || buildUuid === '')) {
+      throw new Error('buildUuid must be a non-empty string when provided');
+    }
+    if (fromLine !== undefined && (typeof fromLine !== 'number' || !Number.isInteger(fromLine) || fromLine < 0)) {
+      throw new Error('fromLine must be a non-negative integer when provided');
+    }
+
+    const { username } = await this.findWebsite(domain);
+    const target = { username, domain };
+
+    const gitSettings = await this.callOperation('hosting_git_auto-deployment-settings', target);
+    const gitAutoDeployment = gitSettings && gitSettings.installation_uuid ? gitSettings : null;
+    const buildSettings = await this.hosting_getDeployment_orNull(this.callOperation('hosting_nodejs_build-settings', target));
 
+    let build: any = null;
+    if (buildUuid !== undefined) {
+      build = await this.callOperation('hosting_nodejs_build', { ...target, uuid: buildUuid });
+    } else {
+      const builds = await this.hosting_getDeployment_orNull(this.callOperation('hosting_nodejs_list-builds', { ...target, per_page: 1 }));
+      build = builds && Array.isArray(builds.data) && builds.data.length > 0 ? builds.data[0] : null;
+    }
+
+    if (build === null) {
       return {
-        upload: {
-          status: 'success',
-          data: {
-            filename: uploadResult.filename
-          }
-        },
-        deploy: {
-          status: 'error',
-          error: errorMessage
-        },
-        removeArchive: {
-          status: archiveRemoved ? 'success' : 'skipped'
-        }
+        domain,
+        build: null,
+        buildSettings,
+        gitAutoDeployment,
+        note: 'No Node.js builds found for this website. Static, PHP, plugin and theme deploys finish before hosting_deploy returns, and a WordPress site import is ready a few minutes after it starts; a Node.js build appears here once one has been started.',
       };
     }
 
-    const archiveRemoved = this.agencyHosting_removeArchive(archivePath, removeArchive);
+    const logs = await this.callOperation('hosting_nodejs_build-logs', { ...target, uuid: build.uuid, from_line: fromLine !== undefined ? fromLine : 0 });
 
     return {
-      upload: {
-        status: 'success',
-        data: {
-          filename: uploadResult.filename
-        }
-      },
-      deploy: {
-        status: 'success',
-        data: deployResult
-      },
-      removeArchive: {
-        status: archiveRemoved ? 'success' : 'skipped'
-      }
+      domain,
+      build,
+      logs,
+      ...(build.state === 'failed' ? { analysis: await this.hosting_getDeployment_analysis(username, domain, build.uuid) } : {}),
+      buildSettings,
+      gitAutoDeployment,
     };
   }
 
-  private normalizePath(pathString: string): string {
-    return pathString.replace(/\\/g, '/');
+  private hosting_importWordpressWebsite_validateArchiveFormat(filePath: string): boolean {
+    const validExtensions = ['zip', 'tar', 'tar.gz', 'tgz', '7z', 'gz', 'gzip'];
+    const fileName = path.basename(filePath).toLowerCase();
+    
+    for (const ext of validExtensions) {
+      if (fileName.endsWith(`.${ext}`)) {
+        return true;
+      }
+    }
+    
+    return false;
+  }
+
+  private hosting_importWordpressWebsite_validateRequiredParams(params: Record<string, any>): void {
+    const { domain, archivePath, databaseDump } = params;
+
+    if (!domain || typeof domain !== 'string') {
+      throw new Error('domain is required and must be a string');
+    }
+
+    if (!archivePath || typeof archivePath !== 'string') {
+      throw new Error('archivePath is required and must be a string');
+    }
+
+    if (!databaseDump || typeof databaseDump !== 'string') {
+      throw new Error('databaseDump is required and must be a string');
+    }
+  }
+
+  private hosting_importWordpressWebsite_validateArchiveFile(archivePath: string): void {
+    if (!fs.existsSync(archivePath)) {
+      throw new Error(`Archive file not found: ${archivePath}`);
+    }
+
+    const archiveStats = fs.statSync(archivePath);
+    if (!archiveStats.isFile()) {
+      throw new Error(`Archive path is not a file: ${archivePath}`);
+    }
+
+    if (!this.hosting_importWordpressWebsite_validateArchiveFormat(archivePath)) {
+      throw new Error('Invalid archive format. Supported formats: zip, tar, tar.gz, tgz, 7z, gz, gzip');
+    }
+  }
+
+  private hosting_importWordpressWebsite_validateDatabaseFile(databaseDump: string): void {
+    if (!fs.existsSync(databaseDump)) {
+      throw new Error(`Database dump file not found: ${databaseDump}`);
+    }
+
+    const dbStats = fs.statSync(databaseDump);
+    if (!dbStats.isFile()) {
+      throw new Error(`Database dump path is not a file: ${databaseDump}`);
+    }
+
+    if (!databaseDump.toLowerCase().endsWith('.sql')) {
+      throw new Error('Database dump must be a .sql file');
+    }
   }
 
-  private async resolveUsername(domain: string): Promise<string> {
+  private async hosting_importWordpressWebsite_checkWebsiteIsEmpty(username: string, domain: string): Promise<boolean> {
     const baseUrl = this.baseUrl.endsWith("/") ? this.baseUrl : `${this.baseUrl}/`;
-    const url = new URL(`api/hosting/v1/websites?domain=${encodeURIComponent(domain)}`, baseUrl).toString();
-    
+    const url = new URL(`api/hosting/v1/accounts/${username}/domains/${domain}/is-empty`, baseUrl).toString();
+
     try {
       const bearerToken = await this.getAuthToken();
-      
+
       const config: AxiosRequestConfig = {
         method: 'get',
         url,
@@ -904,30 +1323,26 @@ class MCPServer {
           return status < 500;
         }
       };
-      
+
       const response = await axios(config);
-      
+
       if (response.status !== 200) {
         throw new Error(`API returned status ${response.status}: ${JSON.stringify(response.data)}`);
       }
-      
-      const websites = response.data?.data;
-      if (!websites || websites.length === 0) {
-        throw new Error(`No website found for domain: ${domain}`);
-      }
-      
-      const username = websites[0].username;
-      if (!username) {
-        throw new Error(`Username not found in website data for domain: ${domain}`);
+
+      const { is_empty } = response.data;
+
+      if (!is_empty) {
+        throw new Error('Website is not empty. WordPress import can only be performed on empty sites. Please visit hPanel (https://hpanel.hostinger.com) and remove all existing files from the website before attempting to import.');
       }
-      
-      this.log('info', `Resolved username: ${username} for domain: ${domain}`);
-      return username;
-      
+
+      this.log('info', `Website ${domain} is empty, proceeding with import`);
+      return true;
+
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      this.log('error', `Failed to resolve username for domain ${domain}: ${errorMessage}`);
-      
+      this.log('error', `Failed to check if website is empty: ${errorMessage}`);
+
       if (axios.isAxiosError(error)) {
         const responseData = error.response?.data;
         const responseStatus = error.response?.status;
@@ -936,14 +1351,14 @@ class MCPServer {
           data: typeof responseData === 'object' ? JSON.stringify(responseData) : responseData
         });
       }
-      
+
       throw error;
     }
   }
 
-  private async fetchUploadCredentials(username: string, domain: string): Promise<{ uploadUrl: string; authRestToken: string; authToken: string }> {
+  private async hosting_importWordpressWebsite_extractFiles(username: string, domain: string, archivePath: string, databaseDump: string): Promise<boolean> {
     const baseUrl = this.baseUrl.endsWith("/") ? this.baseUrl : `${this.baseUrl}/`;
-    const url = new URL('api/hosting/v1/files/upload-urls', baseUrl).toString();
+    const url = new URL(`api/hosting/v1/accounts/${username}/websites/${domain}/wordpress/import`, baseUrl).toString();
 
     try {
       const bearerToken = await this.getAuthToken();
@@ -957,8 +1372,8 @@ class MCPServer {
           'Content-Type': 'application/json'
         },
         data: {
-          username,
-          domain
+          archive_path: path.basename(archivePath),
+          sql_path: path.basename(databaseDump)
         },
         timeout: 60000, // 60s
         validateStatus: function (status: number): boolean {
@@ -968,15 +1383,12 @@ class MCPServer {
 
       const response = await axios(config);
 
-      if (response.status !== 200) {
-        throw new Error(`API returned status ${response.status}: ${JSON.stringify(response.data)}`);
-      }
-
-      return response.data;
+      this.log('info', `Successfully triggered file extraction for ${domain}`);
+      return true;
 
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      this.log('error', `Failed to fetch upload credentials: ${errorMessage}`);
+      this.log('error', `Failed to trigger file extraction: ${errorMessage}`);
 
       if (axios.isAxiosError(error)) {
         const responseData = error.response?.data;
@@ -991,169 +1403,202 @@ class MCPServer {
     }
   }
 
-  private async uploadFile(
-    filePath: string, 
-    relativePath: string, 
-    uploadUrl: string, 
-    authRestToken: string, 
-    authToken: string
-  ): Promise<{ url: string; filename: string }> {
-    return new Promise(async (resolve, reject) => {
+  private async handleWordpressWebsiteImport(params: Record<string, any>): Promise<any> {
+    const { domain, archivePath, databaseDump } = params;
+
+    this.hosting_importWordpressWebsite_validateRequiredParams(params);
+    this.hosting_importWordpressWebsite_validateArchiveFile(archivePath);
+    this.hosting_importWordpressWebsite_validateDatabaseFile(databaseDump);
+
+    // Auto-resolve username from domain
+    this.log('info', `Resolving username from domain: ${domain}`);
+    const username = await this.resolveUsername(domain);
+
+    await this.hosting_importWordpressWebsite_checkWebsiteIsEmpty(username, domain);
+
+    const filesToUpload: Array<{absolutePath: string, relativePath: string, type: string}> = [{
+      absolutePath: archivePath,
+      relativePath: path.basename(archivePath),
+      type: 'archive'
+    }, {
+      absolutePath: databaseDump,
+      relativePath: path.basename(databaseDump),
+      type: 'database'
+    }];
+
+    let uploadCredentials: any;
+    try {
+      uploadCredentials = await this.fetchUploadCredentials(username, domain);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to fetch upload credentials: ${errorMessage}`);
+    }
+
+    const { url: uploadUrl, auth_key: authToken, rest_auth_key: authRestToken } = uploadCredentials;
+
+    if (!uploadUrl || !authToken || !authRestToken) {
+      throw new Error('Invalid upload credentials received from API');
+    }
+
+    this.log('info', `Starting website archive import to ${uploadUrl}`);
+
+    const results: any[] = [];
+    let successCount = 0;
+    let failureCount = 0;
+
+    for (const fileInfo of filesToUpload) {
       try {
-        const stats = fs.statSync(filePath);
-        const fileStream = fs.createReadStream(filePath);
-        
-        const cleanUploadUrl = uploadUrl.replace(new RegExp('/$'), '');
-        const normalizedPath = this.normalizePath(relativePath);
-        const uploadUrlWithFile = `${cleanUploadUrl}/${normalizedPath}?override=true`;
+        this.log('info', `Uploading ${fileInfo.type}: ${fileInfo.absolutePath}`);
 
-        const requestHeaders: Record<string, string> = {
-          'X-Auth': authToken,
-          'X-Auth-Rest': authRestToken,
-          'upload-length': stats.size.toString(),
-          'upload-offset': '0'
-        };
+        const stats = fs.statSync(fileInfo.absolutePath);
+        const uploadResult = await this.uploadFile(
+          fileInfo.absolutePath,
+          fileInfo.relativePath,
+          uploadUrl,
+          authRestToken,
+          authToken
+        );
 
-        try {
-          this.log('debug', `Making pre-upload POST request to ${uploadUrlWithFile}`);
-          await axios.post(uploadUrlWithFile, '', {
-            headers: requestHeaders,
-            timeout: 60000, // 60s
-            validateStatus: function (status: number): boolean {
-              return status == 201;
-            }
-          });
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          
-          if (axios.isAxiosError(error)) {
-            const responseData = error.response?.data;
-            const responseStatus = error.response?.status;
-            const responseHeaders = error.response?.headers;
-            const responseText = typeof responseData === 'object' ? JSON.stringify(responseData) : responseData;
-            
-            this.log('error', 'Pre-upload POST request failed - Full Response Details:', {
-              status: responseStatus,
-              headers: responseHeaders,
-              data: responseText,
-              message: errorMessage
-            });
-            reject(new Error(`Pre-upload request failed: ${errorMessage}`));
-            return;
-          } else {
-            this.log('error', `Pre-upload POST request failed: ${errorMessage}`);
-            reject(new Error(`Pre-upload request failed: ${errorMessage}`));
-            return;
-          }
-        }
+        results.push({
+          file: fileInfo.absolutePath,
+          remotePath: fileInfo.relativePath,
+          type: fileInfo.type,
+          status: 'success',
+          uploadUrl: uploadResult.url,
+          size: stats.size
+        });
 
-        const upload = new tus.Upload(fileStream, {
-          uploadUrl: uploadUrlWithFile,
-          retryDelays: [1000, 2000, 4000, 8000, 16000, 20000],
-          uploadDataDuringCreation: false,
-          parallelUploads: 1,
-          chunkSize: 10485760,
-          headers: requestHeaders,
-          removeFingerprintOnSuccess: true,
-          uploadSize: stats.size,
-          metadata: {
-            filename: path.basename(relativePath)
-          },
-          onError: (error: Error) => {
-            this.log('error', `TUS upload error for ${relativePath}`, { error: error.message });
-            reject(new Error(`Upload failed: ${error.message}`));
-          },
-          onSuccess: () => {
-            this.log('info', `TUS upload completed for ${relativePath}`, { url: upload.url });
-            resolve({
-              url: upload.url || uploadUrlWithFile,
-              filename: relativePath
-            });
-          }
+        successCount++;
+        this.log('info', `Successfully uploaded ${fileInfo.type}: ${fileInfo.relativePath}`);
+
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        results.push({
+          file: fileInfo.absolutePath,
+          remotePath: fileInfo.relativePath,
+          type: fileInfo.type,
+          status: 'error',
+          error: errorMessage
         });
 
-        upload.start();
+        failureCount++;
+        this.log('error', `Failed to upload ${fileInfo.type} ${fileInfo.absolutePath}: ${errorMessage}`);
+      }
+    }
+
+    const overallStatus = failureCount === 0 ? 'success' : (successCount === 0 ? 'failure' : 'partial');
 
+    if (failureCount === 0) {
+      try {
+        this.log('info', 'All files uploaded successfully, triggering extraction...');
+        await this.hosting_importWordpressWebsite_extractFiles(username, domain, archivePath, databaseDump);
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        this.log('error', `Error preparing upload for ${filePath}`, { error: errorMessage });
-        reject(new Error(`Failed to prepare upload: ${errorMessage}`));
+        this.log('error', `File extraction failed: ${errorMessage}`);
+        return {
+          status: 'partial',
+          summary: {
+            total: filesToUpload.length,
+            successful: successCount,
+            failed: failureCount
+          },
+          results,
+          extractionError: errorMessage
+        };
       }
-    });
+    }
+
+    return {
+      status: overallStatus,
+      summary: {
+        total: filesToUpload.length,
+        successful: successCount,
+        failed: failureCount
+      },
+      results
+    };
   }
 
-  private hosting_importWordpressWebsite_validateArchiveFormat(filePath: string): boolean {
-    const validExtensions = ['zip', 'tar', 'tar.gz', 'tgz', '7z', 'gz', 'gzip'];
-    const fileName = path.basename(filePath).toLowerCase();
-    
-    for (const ext of validExtensions) {
-      if (fileName.endsWith(`.${ext}`)) {
-        return true;
-      }
+  private hosting_deployWordpressPlugin_generateRandomString(length: number): string {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    let result = '';
+    for (let i = 0; i < length; i++) {
+      result += chars.charAt(Math.floor(Math.random() * chars.length));
     }
-    
-    return false;
+    return result;
   }
 
-  private hosting_importWordpressWebsite_validateRequiredParams(params: Record<string, any>): void {
-    const { domain, archivePath, databaseDump } = params;
+  private hosting_deployWordpressPlugin_validateRequiredParams(params: Record<string, any>): void {
+    const { domain, slug, pluginPath } = params;
 
     if (!domain || typeof domain !== 'string') {
       throw new Error('domain is required and must be a string');
     }
 
-    if (!archivePath || typeof archivePath !== 'string') {
-      throw new Error('archivePath is required and must be a string');
+    if (!slug || typeof slug !== 'string') {
+      throw new Error('slug is required and must be a string');
     }
 
-    if (!databaseDump || typeof databaseDump !== 'string') {
-      throw new Error('databaseDump is required and must be a string');
+    if (!pluginPath || typeof pluginPath !== 'string') {
+      throw new Error('pluginPath is required and must be a string');
     }
   }
 
-  private hosting_importWordpressWebsite_validateArchiveFile(archivePath: string): void {
-    if (!fs.existsSync(archivePath)) {
-      throw new Error(`Archive file not found: ${archivePath}`);
-    }
-
-    const archiveStats = fs.statSync(archivePath);
-    if (!archiveStats.isFile()) {
-      throw new Error(`Archive path is not a file: ${archivePath}`);
+  private hosting_deployWordpressPlugin_validatePluginDirectory(pluginPath: string): void {
+    if (!fs.existsSync(pluginPath)) {
+      throw new Error(`Plugin directory not found: ${pluginPath}`);
     }
 
-    if (!this.hosting_importWordpressWebsite_validateArchiveFormat(archivePath)) {
-      throw new Error('Invalid archive format. Supported formats: zip, tar, tar.gz, tgz, 7z, gz, gzip');
+    const pluginStats = fs.statSync(pluginPath);
+    if (!pluginStats.isDirectory()) {
+      throw new Error(`Plugin path is not a directory: ${pluginPath}`);
     }
   }
 
-  private hosting_importWordpressWebsite_validateDatabaseFile(databaseDump: string): void {
-    if (!fs.existsSync(databaseDump)) {
-      throw new Error(`Database dump file not found: ${databaseDump}`);
-    }
-
-    const dbStats = fs.statSync(databaseDump);
-    if (!dbStats.isFile()) {
-      throw new Error(`Database dump path is not a file: ${databaseDump}`);
-    }
-
-    if (!databaseDump.toLowerCase().endsWith('.sql')) {
-      throw new Error('Database dump must be a .sql file');
-    }
+  private hosting_deployWordpressPlugin_scanDirectory(dirPath: string, basePath: string = dirPath): Array<{absolutePath: string, relativePath: string}> {
+    const files: Array<{absolutePath: string, relativePath: string}> = [];
+    
+    const scanDir = (currentPath: string) => {
+      const items = fs.readdirSync(currentPath);
+      
+      for (const item of items) {
+        const itemPath = path.join(currentPath, item);
+        const stats = fs.statSync(itemPath);
+        
+        if (stats.isDirectory()) {
+          scanDir(itemPath);
+        } else if (stats.isFile()) {
+          const relativePath = path.relative(basePath, itemPath);
+          files.push({
+            absolutePath: itemPath,
+            relativePath: relativePath
+          });
+        }
+      }
+    };
+    
+    scanDir(dirPath);
+    return files;
   }
 
-  private async hosting_importWordpressWebsite_checkWebsiteIsEmpty(username: string, domain: string): Promise<boolean> {
+  private async hosting_deployWordpressPlugin_deployPlugin(username: string, domain: string, slug: string, pluginPath: string): Promise<boolean> {
     const baseUrl = this.baseUrl.endsWith("/") ? this.baseUrl : `${this.baseUrl}/`;
-    const url = new URL(`api/hosting/v1/accounts/${username}/domains/${domain}/is-empty`, baseUrl).toString();
+    const url = new URL(`api/hosting/v1/accounts/${username}/websites/${domain}/wordpress/plugins/deploy`, baseUrl).toString();
 
     try {
       const bearerToken = await this.getAuthToken();
 
       const config: AxiosRequestConfig = {
-        method: 'get',
+        method: 'post',
         url,
         headers: {
           ...this.headers,
-          'Authorization': `Bearer ${bearerToken}`
+          'Authorization': `Bearer ${bearerToken}`,
+          'Content-Type': 'application/json'
+        },
+        data: {
+          slug,
+          plugin_path: pluginPath
         },
         timeout: 60000, // 60s
         validateStatus: function (status: number): boolean {
@@ -1167,35 +1612,209 @@ class MCPServer {
         throw new Error(`API returned status ${response.status}: ${JSON.stringify(response.data)}`);
       }
 
-      const { is_empty } = response.data;
+      this.log('info', `Successfully triggered plugin deployment for ${domain}`);
+      return true;
 
-      if (!is_empty) {
-        throw new Error('Website is not empty. WordPress import can only be performed on empty sites. Please visit hPanel (https://hpanel.hostinger.com) and remove all existing files from the website before attempting to import.');
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.log('error', `Failed to trigger plugin deployment: ${errorMessage}`);
+
+      if (axios.isAxiosError(error)) {
+        const responseData = error.response?.data;
+        const responseStatus = error.response?.status;
+        this.log('error', 'API Error Details:', {
+          status: responseStatus,
+          data: typeof responseData === 'object' ? JSON.stringify(responseData) : responseData
+        });
+      }
+
+      throw error;
+    }
+  }
+
+  private async handleWordpressPluginDeploy(params: Record<string, any>): Promise<any> {
+    const { domain, slug, pluginPath } = params;
+
+    this.hosting_deployWordpressPlugin_validateRequiredParams(params);
+    this.hosting_deployWordpressPlugin_validatePluginDirectory(pluginPath);
+
+    this.log('info', `Resolving username from domain: ${domain}`);
+    const username = await this.resolveUsername(domain);
+
+    const randomSuffix = this.hosting_deployWordpressPlugin_generateRandomString(8);
+    const uploadDirName = `${slug}-${randomSuffix}`;
+
+    this.log('info', `Scanning plugin directory: ${pluginPath}`);
+    const pluginFiles = this.hosting_deployWordpressPlugin_scanDirectory(pluginPath);
+
+    if (pluginFiles.length === 0) {
+      throw new Error(`No files found in plugin directory: ${pluginPath}`);
+    }
+
+    this.log('info', `Found ${pluginFiles.length} files to upload`);
+
+    let uploadCredentials: any;
+    try {
+      uploadCredentials = await this.fetchUploadCredentials(username, domain);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to fetch upload credentials: ${errorMessage}`);
+    }
+
+    const { url: uploadUrl, auth_key: authToken, rest_auth_key: authRestToken } = uploadCredentials;
+
+    if (!uploadUrl || !authToken || !authRestToken) {
+      throw new Error('Invalid upload credentials received from API');
+    }
+
+    this.log('info', `Starting plugin file upload to ${uploadUrl}`);
+
+    const results: any[] = [];
+    let successCount = 0;
+    let failureCount = 0;
+
+    for (const fileInfo of pluginFiles) {
+      try {
+        const normalizedRelativePath = this.normalizePath(fileInfo.relativePath);
+        const uploadPath = `wp-content/plugins/${uploadDirName}/${normalizedRelativePath}`;
+        this.log('info', `Uploading: ${fileInfo.absolutePath} -> ${uploadPath}`);
+
+        const stats = fs.statSync(fileInfo.absolutePath);
+        const uploadResult = await this.uploadFile(
+          fileInfo.absolutePath,
+          uploadPath,
+          uploadUrl,
+          authRestToken,
+          authToken
+        );
+
+        results.push({
+          file: fileInfo.absolutePath,
+          remotePath: uploadPath,
+          status: 'success',
+          uploadUrl: uploadResult.url,
+          size: stats.size
+        });
+
+        successCount++;
+        this.log('info', `Successfully uploaded: ${uploadPath}`);
+
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const normalizedRelativePath = this.normalizePath(fileInfo.relativePath);
+        const uploadPath = `wp-content/plugins/${uploadDirName}/${normalizedRelativePath}`;
+        
+        results.push({
+          file: fileInfo.absolutePath,
+          remotePath: uploadPath,
+          status: 'error',
+          error: errorMessage
+        });
+
+        failureCount++;
+        this.log('error', `Failed to upload ${fileInfo.absolutePath}: ${errorMessage}`);
+      }
+    }
+
+    const overallStatus = failureCount === 0 ? 'success' : (successCount === 0 ? 'failure' : 'partial');
+
+    if (failureCount === 0) {
+      try {
+        this.log('info', 'All files uploaded successfully, triggering plugin deployment...');
+        await this.hosting_deployWordpressPlugin_deployPlugin(username, domain, slug, uploadDirName);
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        this.log('error', `Plugin deployment failed: ${errorMessage}`);
+        return {
+          status: 'partial',
+          summary: {
+            total: pluginFiles.length,
+            successful: successCount,
+            failed: failureCount
+          },
+          results,
+          deploymentError: errorMessage
+        };
       }
+    }
+
+    return {
+      status: overallStatus,
+      summary: {
+        total: pluginFiles.length,
+        successful: successCount,
+        failed: failureCount
+      },
+      results,
+      uploadDirName
+    };
+  }
+
+  private hosting_deployWordpressTheme_generateRandomString(length: number): string {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    let result = '';
+    for (let i = 0; i < length; i++) {
+      result += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return result;
+  }
+
+  private hosting_deployWordpressTheme_validateRequiredParams(params: Record<string, any>): void {
+    const { domain, slug, themePath } = params;
+
+    if (!domain || typeof domain !== 'string') {
+      throw new Error('domain is required and must be a string');
+    }
 
-      this.log('info', `Website ${domain} is empty, proceeding with import`);
-      return true;
+    if (!slug || typeof slug !== 'string') {
+      throw new Error('slug is required and must be a string');
+    }
 
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      this.log('error', `Failed to check if website is empty: ${errorMessage}`);
+    if (!themePath || typeof themePath !== 'string') {
+      throw new Error('themePath is required and must be a string');
+    }
+  }
 
-      if (axios.isAxiosError(error)) {
-        const responseData = error.response?.data;
-        const responseStatus = error.response?.status;
-        this.log('error', 'API Error Details:', {
-          status: responseStatus,
-          data: typeof responseData === 'object' ? JSON.stringify(responseData) : responseData
-        });
-      }
+  private hosting_deployWordpressTheme_validateThemeDirectory(themePath: string): void {
+    if (!fs.existsSync(themePath)) {
+      throw new Error(`Theme directory not found: ${themePath}`);
+    }
 
-      throw error;
+    const themeStats = fs.statSync(themePath);
+    if (!themeStats.isDirectory()) {
+      throw new Error(`Theme path is not a directory: ${themePath}`);
     }
   }
 
-  private async hosting_importWordpressWebsite_extractFiles(username: string, domain: string, archivePath: string, databaseDump: string): Promise<boolean> {
+  private hosting_deployWordpressTheme_scanDirectory(dirPath: string, basePath: string = dirPath): Array<{absolutePath: string, relativePath: string}> {
+    const files: Array<{absolutePath: string, relativePath: string}> = [];
+    
+    const scanDir = (currentPath: string) => {
+      const items = fs.readdirSync(currentPath);
+      
+      for (const item of items) {
+        const itemPath = path.join(currentPath, item);
+        const stats = fs.statSync(itemPath);
+        
+        if (stats.isDirectory()) {
+          scanDir(itemPath);
+        } else if (stats.isFile()) {
+          const relativePath = path.relative(basePath, itemPath);
+          files.push({
+            absolutePath: itemPath,
+            relativePath: relativePath
+          });
+        }
+      }
+    };
+    
+    scanDir(dirPath);
+    return files;
+  }
+
+  private async hosting_deployWordpressTheme_deployTheme(username: string, domain: string, slug: string, themePath: string, activate: boolean = false): Promise<boolean> {
     const baseUrl = this.baseUrl.endsWith("/") ? this.baseUrl : `${this.baseUrl}/`;
-    const url = new URL(`api/hosting/v1/accounts/${username}/websites/${domain}/wordpress/import`, baseUrl).toString();
+    const url = new URL(`api/hosting/v1/accounts/${username}/websites/${domain}/wordpress/themes/deploy`, baseUrl).toString();
 
     try {
       const bearerToken = await this.getAuthToken();
@@ -1209,8 +1828,9 @@ class MCPServer {
           'Content-Type': 'application/json'
         },
         data: {
-          archive_path: path.basename(archivePath),
-          sql_path: path.basename(databaseDump)
+          slug,
+          theme_path: themePath,
+          is_activated: activate
         },
         timeout: 60000, // 60s
         validateStatus: function (status: number): boolean {
@@ -1220,12 +1840,16 @@ class MCPServer {
 
       const response = await axios(config);
 
-      this.log('info', `Successfully triggered file extraction for ${domain}`);
+      if (response.status !== 200) {
+        throw new Error(`API returned status ${response.status}: ${JSON.stringify(response.data)}`);
+      }
+
+      this.log('info', `Successfully triggered theme deployment for ${domain}`);
       return true;
 
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      this.log('error', `Failed to trigger file extraction: ${errorMessage}`);
+      this.log('error', `Failed to trigger theme deployment: ${errorMessage}`);
 
       if (axios.isAxiosError(error)) {
         const responseData = error.response?.data;
@@ -1240,28 +1864,26 @@ class MCPServer {
     }
   }
 
-  private async handleWordpressWebsiteImport(params: Record<string, any>): Promise<any> {
-    const { domain, archivePath, databaseDump } = params;
+  private async handleWordpressThemeDeploy(params: Record<string, any>): Promise<any> {
+    const { domain, slug, themePath, activate = false } = params;
 
-    this.hosting_importWordpressWebsite_validateRequiredParams(params);
-    this.hosting_importWordpressWebsite_validateArchiveFile(archivePath);
-    this.hosting_importWordpressWebsite_validateDatabaseFile(databaseDump);
+    this.hosting_deployWordpressTheme_validateRequiredParams(params);
+    this.hosting_deployWordpressTheme_validateThemeDirectory(themePath);
 
-    // Auto-resolve username from domain
     this.log('info', `Resolving username from domain: ${domain}`);
     const username = await this.resolveUsername(domain);
 
-    await this.hosting_importWordpressWebsite_checkWebsiteIsEmpty(username, domain);
+    const randomSuffix = this.hosting_deployWordpressTheme_generateRandomString(8);
+    const uploadDirName = `${slug}-${randomSuffix}`;
 
-    const filesToUpload: Array<{absolutePath: string, relativePath: string, type: string}> = [{
-      absolutePath: archivePath,
-      relativePath: path.basename(archivePath),
-      type: 'archive'
-    }, {
-      absolutePath: databaseDump,
-      relativePath: path.basename(databaseDump),
-      type: 'database'
-    }];
+    this.log('info', `Scanning theme directory: ${themePath}`);
+    const themeFiles = this.hosting_deployWordpressTheme_scanDirectory(themePath);
+
+    if (themeFiles.length === 0) {
+      throw new Error(`No files found in theme directory: ${themePath}`);
+    }
+
+    this.log('info', `Found ${themeFiles.length} files to upload`);
 
     let uploadCredentials: any;
     try {
@@ -1277,20 +1899,22 @@ class MCPServer {
       throw new Error('Invalid upload credentials received from API');
     }
 
-    this.log('info', `Starting website archive import to ${uploadUrl}`);
+    this.log('info', `Starting theme file upload to ${uploadUrl}`);
 
     const results: any[] = [];
     let successCount = 0;
     let failureCount = 0;
 
-    for (const fileInfo of filesToUpload) {
+    for (const fileInfo of themeFiles) {
       try {
-        this.log('info', `Uploading ${fileInfo.type}: ${fileInfo.absolutePath}`);
+        const normalizedRelativePath = this.normalizePath(fileInfo.relativePath);
+        const uploadPath = `wp-content/themes/${uploadDirName}/${normalizedRelativePath}`;
+        this.log('info', `Uploading: ${fileInfo.absolutePath} -> ${uploadPath}`);
 
         const stats = fs.statSync(fileInfo.absolutePath);
         const uploadResult = await this.uploadFile(
           fileInfo.absolutePath,
-          fileInfo.relativePath,
+          uploadPath,
           uploadUrl,
           authRestToken,
           authToken
@@ -1298,28 +1922,29 @@ class MCPServer {
 
         results.push({
           file: fileInfo.absolutePath,
-          remotePath: fileInfo.relativePath,
-          type: fileInfo.type,
+          remotePath: uploadPath,
           status: 'success',
           uploadUrl: uploadResult.url,
           size: stats.size
         });
 
         successCount++;
-        this.log('info', `Successfully uploaded ${fileInfo.type}: ${fileInfo.relativePath}`);
+        this.log('info', `Successfully uploaded: ${uploadPath}`);
 
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
+        const normalizedRelativePath = this.normalizePath(fileInfo.relativePath);
+        const uploadPath = `wp-content/themes/${uploadDirName}/${normalizedRelativePath}`;
+        
         results.push({
           file: fileInfo.absolutePath,
-          remotePath: fileInfo.relativePath,
-          type: fileInfo.type,
+          remotePath: uploadPath,
           status: 'error',
           error: errorMessage
         });
 
         failureCount++;
-        this.log('error', `Failed to upload ${fileInfo.type} ${fileInfo.absolutePath}: ${errorMessage}`);
+        this.log('error', `Failed to upload ${fileInfo.absolutePath}: ${errorMessage}`);
       }
     }
 
@@ -1327,20 +1952,20 @@ class MCPServer {
 
     if (failureCount === 0) {
       try {
-        this.log('info', 'All files uploaded successfully, triggering extraction...');
-        await this.hosting_importWordpressWebsite_extractFiles(username, domain, archivePath, databaseDump);
+        this.log('info', 'All files uploaded successfully, triggering theme deployment...');
+        await this.hosting_deployWordpressTheme_deployTheme(username, domain, slug, uploadDirName, activate);
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        this.log('error', `File extraction failed: ${errorMessage}`);
+        this.log('error', `Theme deployment failed: ${errorMessage}`);
         return {
           status: 'partial',
           summary: {
-            total: filesToUpload.length,
+            total: themeFiles.length,
             successful: successCount,
             failed: failureCount
           },
           results,
-          extractionError: errorMessage
+          deploymentError: errorMessage
         };
       }
     }
@@ -1348,83 +1973,142 @@ class MCPServer {
     return {
       status: overallStatus,
       summary: {
-        total: filesToUpload.length,
+        total: themeFiles.length,
         successful: successCount,
         failed: failureCount
       },
-      results
+      results,
+      uploadDirName,
+      activated: activate
     };
   }
 
-  private hosting_deployWordpressPlugin_generateRandomString(length: number): string {
-    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
-    let result = '';
-    for (let i = 0; i < length; i++) {
-      result += chars.charAt(Math.floor(Math.random() * chars.length));
+  private hosting_deployJsApplication_validateArchiveFormat(filePath: string): boolean {
+    const validExtensions = ['zip', 'tar', 'tar.gz', 'tgz', '7z', 'gz', 'gzip'];
+    const fileName = path.basename(filePath).toLowerCase();
+    
+    for (const ext of validExtensions) {
+      if (fileName.endsWith(`.${ext}`)) {
+        return true;
+      }
     }
-    return result;
+    
+    return false;
   }
 
-  private hosting_deployWordpressPlugin_validateRequiredParams(params: Record<string, any>): void {
-    const { domain, slug, pluginPath } = params;
+  private hosting_deployJsApplication_validateRequiredParams(params: Record<string, any>): void {
+    const { domain, archivePath, removeArchive } = params;
 
     if (!domain || typeof domain !== 'string') {
       throw new Error('domain is required and must be a string');
     }
 
-    if (!slug || typeof slug !== 'string') {
-      throw new Error('slug is required and must be a string');
+    if (!archivePath || typeof archivePath !== 'string') {
+      throw new Error('archivePath is required and must be a string');
     }
 
-    if (!pluginPath || typeof pluginPath !== 'string') {
-      throw new Error('pluginPath is required and must be a string');
+    if (removeArchive !== undefined && typeof removeArchive !== 'boolean') {
+      throw new Error('removeArchive must be a boolean if provided');
     }
   }
 
-  private hosting_deployWordpressPlugin_validatePluginDirectory(pluginPath: string): void {
-    if (!fs.existsSync(pluginPath)) {
-      throw new Error(`Plugin directory not found: ${pluginPath}`);
+  private hosting_deployJsApplication_removeArchive(archivePath: string, removeArchive: boolean): boolean {
+    if (!removeArchive) {
+      return false;
     }
 
-    const pluginStats = fs.statSync(pluginPath);
-    if (!pluginStats.isDirectory()) {
-      throw new Error(`Plugin path is not a directory: ${pluginPath}`);
+    try {
+      this.log('info', `Removing archive file: ${archivePath}`);
+      fs.unlinkSync(archivePath);
+      this.log('info', `Successfully removed archive file: ${archivePath}`);
+      return true;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.log('error', `Failed to remove archive file: ${errorMessage}`);
+      // Don't fail the entire operation if archive removal fails
+      return false;
     }
   }
 
-  private hosting_deployWordpressPlugin_scanDirectory(dirPath: string, basePath: string = dirPath): Array<{absolutePath: string, relativePath: string}> {
-    const files: Array<{absolutePath: string, relativePath: string}> = [];
-    
-    const scanDir = (currentPath: string) => {
-      const items = fs.readdirSync(currentPath);
-      
-      for (const item of items) {
-        const itemPath = path.join(currentPath, item);
-        const stats = fs.statSync(itemPath);
-        
-        if (stats.isDirectory()) {
-          scanDir(itemPath);
-        } else if (stats.isFile()) {
-          const relativePath = path.relative(basePath, itemPath);
-          files.push({
-            absolutePath: itemPath,
-            relativePath: relativePath
-          });
+  private hosting_deployJsApplication_validateArchiveFile(archivePath: string): void {
+    if (!fs.existsSync(archivePath)) {
+      throw new Error(`Archive file not found: ${archivePath}`);
+    }
+
+    const archiveStats = fs.statSync(archivePath);
+    if (!archiveStats.isFile()) {
+      throw new Error(`Archive path is not a file: ${archivePath}`);
+    }
+
+    if (!this.hosting_deployJsApplication_validateArchiveFormat(archivePath)) {
+      throw new Error('Invalid archive format. Supported formats: zip, tar, tar.gz, tgz, 7z, gz, gzip');
+    }
+  }
+
+  private async hosting_deployJsApplication_fetchBuildSettings(username: string, domain: string, archivePath: string): Promise<any> {
+    const baseUrl = this.baseUrl.endsWith("/") ? this.baseUrl : `${this.baseUrl}/`;
+    const archiveBasename = path.basename(archivePath);
+    const url = new URL(`api/hosting/v1/accounts/${username}/websites/${domain}/nodejs/builds/settings/from-archive?archive_path=${encodeURIComponent(archiveBasename)}`, baseUrl).toString();
+
+    try {
+      const bearerToken = await this.getAuthToken();
+
+      const config: AxiosRequestConfig = {
+        method: 'get',
+        url,
+        headers: {
+          ...this.headers,
+          'Authorization': `Bearer ${bearerToken}`
+        },
+        timeout: 60000, // 60s
+        validateStatus: function (status: number): boolean {
+          return status < 500;
         }
+      };
+
+      const response = await axios(config);
+
+      if (response.status !== 200) {
+        throw new Error(`API returned status ${response.status}: ${JSON.stringify(response.data)}`);
+      }
+
+      this.log('info', `Successfully fetched build settings for ${domain}`);
+      return response.data;
+
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.log('error', `Failed to fetch build settings: ${errorMessage}`);
+
+      if (axios.isAxiosError(error)) {
+        const responseData = error.response?.data;
+        const responseStatus = error.response?.status;
+        this.log('error', 'API Error Details:', {
+          status: responseStatus,
+          data: typeof responseData === 'object' ? JSON.stringify(responseData) : responseData
+        });
       }
-    };
-    
-    scanDir(dirPath);
-    return files;
+
+      throw error;
+    }
   }
 
-  private async hosting_deployWordpressPlugin_deployPlugin(username: string, domain: string, slug: string, pluginPath: string): Promise<boolean> {
+  private async hosting_deployJsApplication_triggerBuild(username: string, domain: string, archivePath: string, buildSettings: any): Promise<any> {
     const baseUrl = this.baseUrl.endsWith("/") ? this.baseUrl : `${this.baseUrl}/`;
-    const url = new URL(`api/hosting/v1/accounts/${username}/websites/${domain}/wordpress/plugins/deploy`, baseUrl).toString();
+    const url = new URL(`api/hosting/v1/accounts/${username}/websites/${domain}/nodejs/builds`, baseUrl).toString();
 
     try {
       const bearerToken = await this.getAuthToken();
 
+      const archiveBasename = path.basename(archivePath);
+      const buildData = {
+        ...buildSettings,
+        node_version: buildSettings?.node_version || 20,
+        source_type: 'archive',
+        source_options: {
+          archive_path: archiveBasename
+        }
+      };
+
       const config: AxiosRequestConfig = {
         method: 'post',
         url,
@@ -1433,10 +2117,7 @@ class MCPServer {
           'Authorization': `Bearer ${bearerToken}`,
           'Content-Type': 'application/json'
         },
-        data: {
-          slug,
-          plugin_path: pluginPath
-        },
+        data: buildData,
         timeout: 60000, // 60s
         validateStatus: function (status: number): boolean {
           return status < 500;
@@ -1449,12 +2130,12 @@ class MCPServer {
         throw new Error(`API returned status ${response.status}: ${JSON.stringify(response.data)}`);
       }
 
-      this.log('info', `Successfully triggered plugin deployment for ${domain}`);
-      return true;
+      this.log('info', `Successfully triggered build for ${domain}`);
+      return response.data;
 
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      this.log('error', `Failed to trigger plugin deployment: ${errorMessage}`);
+      this.log('error', `Failed to trigger build: ${errorMessage}`);
 
       if (axios.isAxiosError(error)) {
         const responseData = error.response?.data;
@@ -1469,27 +2150,19 @@ class MCPServer {
     }
   }
 
-  private async handleWordpressPluginDeploy(params: Record<string, any>): Promise<any> {
-    const { domain, slug, pluginPath } = params;
+  private async handleJavascriptApplicationDeploy(params: Record<string, any>): Promise<any> {
+    const { domain, archivePath, removeArchive = false } = params;
 
-    this.hosting_deployWordpressPlugin_validateRequiredParams(params);
-    this.hosting_deployWordpressPlugin_validatePluginDirectory(pluginPath);
+    this.hosting_deployJsApplication_validateRequiredParams(params);
+    this.hosting_deployJsApplication_validateArchiveFile(archivePath);
 
+    // Auto-resolve username from domain
     this.log('info', `Resolving username from domain: ${domain}`);
     const username = await this.resolveUsername(domain);
 
-    const randomSuffix = this.hosting_deployWordpressPlugin_generateRandomString(8);
-    const uploadDirName = `${slug}-${randomSuffix}`;
-
-    this.log('info', `Scanning plugin directory: ${pluginPath}`);
-    const pluginFiles = this.hosting_deployWordpressPlugin_scanDirectory(pluginPath);
-
-    if (pluginFiles.length === 0) {
-      throw new Error(`No files found in plugin directory: ${pluginPath}`);
-    }
-
-    this.log('info', `Found ${pluginFiles.length} files to upload`);
-
+    // Upload archive file
+    this.log('info', `Starting archive upload for ${domain}`);
+    
     let uploadCredentials: any;
     try {
       uploadCredentials = await this.fetchUploadCredentials(username, domain);
@@ -1504,158 +2177,181 @@ class MCPServer {
       throw new Error('Invalid upload credentials received from API');
     }
 
-    this.log('info', `Starting plugin file upload to ${uploadUrl}`);
-
-    const results: any[] = [];
-    let successCount = 0;
-    let failureCount = 0;
+    const archiveBasename = path.basename(archivePath);
+    let uploadResult: any;
+    try {
+      const stats = fs.statSync(archivePath);
+      uploadResult = await this.uploadFile(
+        archivePath,
+        archiveBasename,
+        uploadUrl,
+        authRestToken,
+        authToken
+      );
 
-    for (const fileInfo of pluginFiles) {
-      try {
-        const normalizedRelativePath = this.normalizePath(fileInfo.relativePath);
-        const uploadPath = `wp-content/plugins/${uploadDirName}/${normalizedRelativePath}`;
-        this.log('info', `Uploading: ${fileInfo.absolutePath} -> ${uploadPath}`);
+      this.log('info', `Successfully uploaded archive: ${archiveBasename}`);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to upload archive: ${errorMessage}`);
+    }
 
-        const stats = fs.statSync(fileInfo.absolutePath);
-        const uploadResult = await this.uploadFile(
-          fileInfo.absolutePath,
-          uploadPath,
-          uploadUrl,
-          authRestToken,
-          authToken
-        );
+    // Fetch build settings
+    let buildSettings: any;
+    try {
+      this.log('info', `Fetching build settings for ${domain}`);
+      buildSettings = await this.hosting_deployJsApplication_fetchBuildSettings(username, domain, archivePath);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.log('error', `Failed to fetch build settings: ${errorMessage}`);
+      const archiveRemoved = this.hosting_deployJsApplication_removeArchive(archivePath, removeArchive);
 
-        results.push({
-          file: fileInfo.absolutePath,
-          remotePath: uploadPath,
+      return {
+        upload: {
           status: 'success',
-          uploadUrl: uploadResult.url,
-          size: stats.size
-        });
-
-        successCount++;
-        this.log('info', `Successfully uploaded: ${uploadPath}`);
-
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        const normalizedRelativePath = this.normalizePath(fileInfo.relativePath);
-        const uploadPath = `wp-content/plugins/${uploadDirName}/${normalizedRelativePath}`;
-        
-        results.push({
-          file: fileInfo.absolutePath,
-          remotePath: uploadPath,
+          data: {
+            filename: uploadResult.filename
+          }
+        },
+        resolveSettings: {
           status: 'error',
           error: errorMessage
-        });
-
-        failureCount++;
-        this.log('error', `Failed to upload ${fileInfo.absolutePath}: ${errorMessage}`);
-      }
+        },
+        build: {
+          status: 'skipped'
+        },
+        removeArchive: {
+          status: archiveRemoved ? 'success' : 'skipped'
+        }
+      };
     }
 
-    const overallStatus = failureCount === 0 ? 'success' : (successCount === 0 ? 'failure' : 'partial');
+    // Trigger build
+    let buildResult: any;
+    try {
+      this.log('info', `Triggering build for ${domain}`);
+      buildResult = await this.hosting_deployJsApplication_triggerBuild(username, domain, archivePath, buildSettings);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.log('error', `Failed to trigger build: ${errorMessage}`);
+      const archiveRemoved = this.hosting_deployJsApplication_removeArchive(archivePath, removeArchive);
 
-    if (failureCount === 0) {
-      try {
-        this.log('info', 'All files uploaded successfully, triggering plugin deployment...');
-        await this.hosting_deployWordpressPlugin_deployPlugin(username, domain, slug, uploadDirName);
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        this.log('error', `Plugin deployment failed: ${errorMessage}`);
-        return {
-          status: 'partial',
-          summary: {
-            total: pluginFiles.length,
-            successful: successCount,
-            failed: failureCount
-          },
-          results,
-          deploymentError: errorMessage
-        };
-      }
+      return {
+        upload: {
+          status: 'success',
+          data: {
+            filename: uploadResult.filename
+          }
+        },
+        resolveSettings: {
+          status: 'success',
+          data: buildSettings
+        },
+        build: {
+          status: 'error',
+          error: errorMessage
+        },
+        removeArchive: {
+          status: archiveRemoved ? 'success' : 'skipped'
+        }
+      };
     }
 
+    const archiveRemoved = this.hosting_deployJsApplication_removeArchive(archivePath, removeArchive);
+
     return {
-      status: overallStatus,
-      summary: {
-        total: pluginFiles.length,
-        successful: successCount,
-        failed: failureCount
+      upload: {
+        status: 'success',
+        data: {
+          filename: uploadResult.filename
+        }
       },
-      results,
-      uploadDirName
+      resolveSettings: {
+        status: 'success',
+        data: buildSettings
+      },
+      build: {
+        status: 'success',
+        data: buildResult
+      },
+      removeArchive: {
+        status: archiveRemoved ? 'success' : 'skipped'
+      }
     };
   }
 
-  private hosting_deployWordpressTheme_generateRandomString(length: number): string {
-    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
-    let result = '';
-    for (let i = 0; i < length; i++) {
-      result += chars.charAt(Math.floor(Math.random() * chars.length));
+  private hosting_deployStaticWebsite_validateArchiveFormat(filePath: string): boolean {
+    const validExtensions = ['zip', 'tar', 'tar.gz', 'tgz', '7z', 'gz', 'gzip'];
+    const fileName = path.basename(filePath).toLowerCase();
+    
+    for (const ext of validExtensions) {
+      if (fileName.endsWith(`.${ext}`)) {
+        return true;
+      }
     }
-    return result;
+    
+    return false;
   }
 
-  private hosting_deployWordpressTheme_validateRequiredParams(params: Record<string, any>): void {
-    const { domain, slug, themePath } = params;
+  private hosting_deployStaticWebsite_validateRequiredParams(params: Record<string, any>): void {
+    const { domain, archivePath, removeArchive } = params;
 
     if (!domain || typeof domain !== 'string') {
       throw new Error('domain is required and must be a string');
     }
 
-    if (!slug || typeof slug !== 'string') {
-      throw new Error('slug is required and must be a string');
+    if (!archivePath || typeof archivePath !== 'string') {
+      throw new Error('archivePath is required and must be a string');
     }
 
-    if (!themePath || typeof themePath !== 'string') {
-      throw new Error('themePath is required and must be a string');
+    if (removeArchive !== undefined && typeof removeArchive !== 'boolean') {
+      throw new Error('removeArchive must be a boolean if provided');
+    }
+  }
+
+  private hosting_deployStaticWebsite_removeArchive(archivePath: string, removeArchive: boolean): boolean {
+    if (!removeArchive) {
+      return false;
+    }
+
+    try {
+      this.log('info', `Removing archive file: ${archivePath}`);
+      fs.unlinkSync(archivePath);
+      this.log('info', `Successfully removed archive file: ${archivePath}`);
+      return true;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.log('error', `Failed to remove archive file: ${errorMessage}`);
+      return false;
     }
   }
 
-  private hosting_deployWordpressTheme_validateThemeDirectory(themePath: string): void {
-    if (!fs.existsSync(themePath)) {
-      throw new Error(`Theme directory not found: ${themePath}`);
+  private hosting_deployStaticWebsite_validateArchiveFile(archivePath: string): void {
+    if (!fs.existsSync(archivePath)) {
+      throw new Error(`Archive file not found: ${archivePath}`);
     }
 
-    const themeStats = fs.statSync(themePath);
-    if (!themeStats.isDirectory()) {
-      throw new Error(`Theme path is not a directory: ${themePath}`);
+    const archiveStats = fs.statSync(archivePath);
+    if (!archiveStats.isFile()) {
+      throw new Error(`Archive path is not a file: ${archivePath}`);
     }
-  }
 
-  private hosting_deployWordpressTheme_scanDirectory(dirPath: string, basePath: string = dirPath): Array<{absolutePath: string, relativePath: string}> {
-    const files: Array<{absolutePath: string, relativePath: string}> = [];
-    
-    const scanDir = (currentPath: string) => {
-      const items = fs.readdirSync(currentPath);
-      
-      for (const item of items) {
-        const itemPath = path.join(currentPath, item);
-        const stats = fs.statSync(itemPath);
-        
-        if (stats.isDirectory()) {
-          scanDir(itemPath);
-        } else if (stats.isFile()) {
-          const relativePath = path.relative(basePath, itemPath);
-          files.push({
-            absolutePath: itemPath,
-            relativePath: relativePath
-          });
-        }
-      }
-    };
-    
-    scanDir(dirPath);
-    return files;
+    if (!this.hosting_deployStaticWebsite_validateArchiveFormat(archivePath)) {
+      throw new Error('Invalid archive format. Supported formats: zip, tar, tar.gz, tgz, 7z, gz, gzip');
+    }
   }
 
-  private async hosting_deployWordpressTheme_deployTheme(username: string, domain: string, slug: string, themePath: string, activate: boolean = false): Promise<boolean> {
+  private async hosting_deployStaticWebsite_triggerDeploy(username: string, domain: string, archivePath: string): Promise<any> {
     const baseUrl = this.baseUrl.endsWith("/") ? this.baseUrl : `${this.baseUrl}/`;
-    const url = new URL(`api/hosting/v1/accounts/${username}/websites/${domain}/wordpress/themes/deploy`, baseUrl).toString();
+    const url = new URL(`api/hosting/v1/accounts/${username}/websites/${domain}/deploy`, baseUrl).toString();
 
     try {
       const bearerToken = await this.getAuthToken();
 
+      const archiveBasename = path.basename(archivePath);
+      const deployData = {
+        archive_path: archiveBasename
+      };
+
       const config: AxiosRequestConfig = {
         method: 'post',
         url,
@@ -1664,12 +2360,8 @@ class MCPServer {
           'Authorization': `Bearer ${bearerToken}`,
           'Content-Type': 'application/json'
         },
-        data: {
-          slug,
-          theme_path: themePath,
-          is_activated: activate
-        },
-        timeout: 60000, // 60s
+        data: deployData,
+        timeout: 60000,
         validateStatus: function (status: number): boolean {
           return status < 500;
         }
@@ -1681,12 +2373,12 @@ class MCPServer {
         throw new Error(`API returned status ${response.status}: ${JSON.stringify(response.data)}`);
       }
 
-      this.log('info', `Successfully triggered theme deployment for ${domain}`);
-      return true;
+      this.log('info', `Successfully triggered deployment for ${domain}`);
+      return response.data;
 
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      this.log('error', `Failed to trigger theme deployment: ${errorMessage}`);
+      this.log('error', `Failed to trigger deployment: ${errorMessage}`);
 
       if (axios.isAxiosError(error)) {
         const responseData = error.response?.data;
@@ -1701,27 +2393,17 @@ class MCPServer {
     }
   }
 
-  private async handleWordpressThemeDeploy(params: Record<string, any>): Promise<any> {
-    const { domain, slug, themePath, activate = false } = params;
+  private async handleStaticWebsiteDeploy(params: Record<string, any>): Promise<any> {
+    const { domain, archivePath, removeArchive = false } = params;
 
-    this.hosting_deployWordpressTheme_validateRequiredParams(params);
-    this.hosting_deployWordpressTheme_validateThemeDirectory(themePath);
+    this.hosting_deployStaticWebsite_validateRequiredParams(params);
+    this.hosting_deployStaticWebsite_validateArchiveFile(archivePath);
 
     this.log('info', `Resolving username from domain: ${domain}`);
     const username = await this.resolveUsername(domain);
 
-    const randomSuffix = this.hosting_deployWordpressTheme_generateRandomString(8);
-    const uploadDirName = `${slug}-${randomSuffix}`;
-
-    this.log('info', `Scanning theme directory: ${themePath}`);
-    const themeFiles = this.hosting_deployWordpressTheme_scanDirectory(themePath);
-
-    if (themeFiles.length === 0) {
-      throw new Error(`No files found in theme directory: ${themePath}`);
-    }
-
-    this.log('info', `Found ${themeFiles.length} files to upload`);
-
+    this.log('info', `Starting archive upload for ${domain}`);
+    
     let uploadCredentials: any;
     try {
       uploadCredentials = await this.fetchUploadCredentials(username, domain);
@@ -1736,163 +2418,110 @@ class MCPServer {
       throw new Error('Invalid upload credentials received from API');
     }
 
-    this.log('info', `Starting theme file upload to ${uploadUrl}`);
-
-    const results: any[] = [];
-    let successCount = 0;
-    let failureCount = 0;
+    const archiveBasename = path.basename(archivePath);
+    let uploadResult: any;
+    try {
+      const stats = fs.statSync(archivePath);
+      uploadResult = await this.uploadFile(
+        archivePath,
+        archiveBasename,
+        uploadUrl,
+        authRestToken,
+        authToken
+      );
 
-    for (const fileInfo of themeFiles) {
-      try {
-        const normalizedRelativePath = this.normalizePath(fileInfo.relativePath);
-        const uploadPath = `wp-content/themes/${uploadDirName}/${normalizedRelativePath}`;
-        this.log('info', `Uploading: ${fileInfo.absolutePath} -> ${uploadPath}`);
+      this.log('info', `Successfully uploaded archive: ${archiveBasename}`);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to upload archive: ${errorMessage}`);
+    }
 
-        const stats = fs.statSync(fileInfo.absolutePath);
-        const uploadResult = await this.uploadFile(
-          fileInfo.absolutePath,
-          uploadPath,
-          uploadUrl,
-          authRestToken,
-          authToken
-        );
+    let deployResult: any;
+    try {
+      this.log('info', `Triggering deployment for ${domain}`);
+      deployResult = await this.hosting_deployStaticWebsite_triggerDeploy(username, domain, archivePath);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.log('error', `Failed to trigger deployment: ${errorMessage}`);
+      const archiveRemoved = this.hosting_deployStaticWebsite_removeArchive(archivePath, removeArchive);
 
-        results.push({
-          file: fileInfo.absolutePath,
-          remotePath: uploadPath,
+      return {
+        upload: {
           status: 'success',
-          uploadUrl: uploadResult.url,
-          size: stats.size
-        });
-
-        successCount++;
-        this.log('info', `Successfully uploaded: ${uploadPath}`);
-
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        const normalizedRelativePath = this.normalizePath(fileInfo.relativePath);
-        const uploadPath = `wp-content/themes/${uploadDirName}/${normalizedRelativePath}`;
-        
-        results.push({
-          file: fileInfo.absolutePath,
-          remotePath: uploadPath,
+          data: {
+            filename: uploadResult.filename
+          }
+        },
+        deploy: {
           status: 'error',
           error: errorMessage
-        });
-
-        failureCount++;
-        this.log('error', `Failed to upload ${fileInfo.absolutePath}: ${errorMessage}`);
-      }
+        },
+        removeArchive: {
+          status: archiveRemoved ? 'success' : 'skipped'
+        }
+      };
     }
 
-    const overallStatus = failureCount === 0 ? 'success' : (successCount === 0 ? 'failure' : 'partial');
-
-    if (failureCount === 0) {
-      try {
-        this.log('info', 'All files uploaded successfully, triggering theme deployment...');
-        await this.hosting_deployWordpressTheme_deployTheme(username, domain, slug, uploadDirName, activate);
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        this.log('error', `Theme deployment failed: ${errorMessage}`);
-        return {
-          status: 'partial',
-          summary: {
-            total: themeFiles.length,
-            successful: successCount,
-            failed: failureCount
-          },
-          results,
-          deploymentError: errorMessage
-        };
-      }
-    }
+    const archiveRemoved = this.hosting_deployStaticWebsite_removeArchive(archivePath, removeArchive);
 
     return {
-      status: overallStatus,
-      summary: {
-        total: themeFiles.length,
-        successful: successCount,
-        failed: failureCount
+      upload: {
+        status: 'success',
+        data: {
+          filename: uploadResult.filename
+        }
       },
-      results,
-      uploadDirName,
-      activated: activate
-    };
-  }
-
-  private hosting_deployJsApplication_validateArchiveFormat(filePath: string): boolean {
-    const validExtensions = ['zip', 'tar', 'tar.gz', 'tgz', '7z', 'gz', 'gzip'];
-    const fileName = path.basename(filePath).toLowerCase();
-    
-    for (const ext of validExtensions) {
-      if (fileName.endsWith(`.${ext}`)) {
-        return true;
+      deploy: {
+        status: 'success',
+        data: deployResult
+      },
+      removeArchive: {
+        status: archiveRemoved ? 'success' : 'skipped'
       }
-    }
-    
-    return false;
+    };
   }
 
-  private hosting_deployJsApplication_validateRequiredParams(params: Record<string, any>): void {
-    const { domain, archivePath, removeArchive } = params;
+  private hosting_listJsDeployments_validateRequiredParams(params: Record<string, any>): void {
+    const { domain } = params;
 
     if (!domain || typeof domain !== 'string') {
       throw new Error('domain is required and must be a string');
     }
-
-    if (!archivePath || typeof archivePath !== 'string') {
-      throw new Error('archivePath is required and must be a string');
-    }
-
-    if (removeArchive !== undefined && typeof removeArchive !== 'boolean') {
-      throw new Error('removeArchive must be a boolean if provided');
-    }
   }
 
-  private hosting_deployJsApplication_removeArchive(archivePath: string, removeArchive: boolean): boolean {
-    if (!removeArchive) {
-      return false;
-    }
+  private hosting_listJsDeployments_buildQueryParams(params: Record<string, any>): string {
+    const { page, perPage, states } = params;
+    const queryParams = new URLSearchParams();
 
-    try {
-      this.log('info', `Removing archive file: ${archivePath}`);
-      fs.unlinkSync(archivePath);
-      this.log('info', `Successfully removed archive file: ${archivePath}`);
-      return true;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      this.log('error', `Failed to remove archive file: ${errorMessage}`);
-      // Don't fail the entire operation if archive removal fails
-      return false;
+    if (page !== undefined && page !== null) {
+      queryParams.append('page', page.toString());
     }
-  }
 
-  private hosting_deployJsApplication_validateArchiveFile(archivePath: string): void {
-    if (!fs.existsSync(archivePath)) {
-      throw new Error(`Archive file not found: ${archivePath}`);
+    if (perPage !== undefined && perPage !== null) {
+      queryParams.append('per_page', perPage.toString());
     }
 
-    const archiveStats = fs.statSync(archivePath);
-    if (!archiveStats.isFile()) {
-      throw new Error(`Archive path is not a file: ${archivePath}`);
+    if (states && Array.isArray(states) && states.length > 0) {
+      states.forEach(state => {
+        queryParams.append('states[]', state);
+      });
     }
 
-    if (!this.hosting_deployJsApplication_validateArchiveFormat(archivePath)) {
-      throw new Error('Invalid archive format. Supported formats: zip, tar, tar.gz, tgz, 7z, gz, gzip');
-    }
+    return queryParams.toString();
   }
 
-  private async hosting_deployJsApplication_fetchBuildSettings(username: string, domain: string, archivePath: string): Promise<any> {
+  private async hosting_listJsDeployments_fetchDeployments(username: string, domain: string, queryParams: string): Promise<any> {
     const baseUrl = this.baseUrl.endsWith("/") ? this.baseUrl : `${this.baseUrl}/`;
-    const archiveBasename = path.basename(archivePath);
-    const url = new URL(`api/hosting/v1/accounts/${username}/websites/${domain}/nodejs/builds/settings/from-archive?archive_path=${encodeURIComponent(archiveBasename)}`, baseUrl).toString();
+    const url = new URL(`api/hosting/v1/accounts/${username}/websites/${domain}/nodejs/builds`, baseUrl).toString();
+    
+    const fullUrl = queryParams ? `${url}?${queryParams}` : url;
 
     try {
       const bearerToken = await this.getAuthToken();
 
       const config: AxiosRequestConfig = {
         method: 'get',
-        url,
+        url: fullUrl,
         headers: {
           ...this.headers,
           'Authorization': `Bearer ${bearerToken}`
@@ -1909,12 +2538,12 @@ class MCPServer {
         throw new Error(`API returned status ${response.status}: ${JSON.stringify(response.data)}`);
       }
 
-      this.log('info', `Successfully fetched build settings for ${domain}`);
+      this.log('info', `Successfully fetched deployments for ${domain}`);
       return response.data;
 
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      this.log('error', `Failed to fetch build settings: ${errorMessage}`);
+      this.log('error', `Failed to fetch deployments: ${errorMessage}`);
 
       if (axios.isAxiosError(error)) {
         const responseData = error.response?.data;
@@ -1929,33 +2558,85 @@ class MCPServer {
     }
   }
 
-  private async hosting_deployJsApplication_triggerBuild(username: string, domain: string, archivePath: string, buildSettings: any): Promise<any> {
+  private async handleListJavascriptDeployments(params: Record<string, any>): Promise<any> {
+    const { domain, page, perPage, states } = params;
+
+    this.hosting_listJsDeployments_validateRequiredParams(params);
+
+    // Auto-resolve username from domain
+    this.log('info', `Resolving username from domain: ${domain}`);
+    const username = await this.resolveUsername(domain);
+
+    // Build query parameters
+    const queryParams = this.hosting_listJsDeployments_buildQueryParams(params);
+
+    // Fetch deployments
+    let deployments: any;
+    try {
+      this.log('info', `Fetching deployments for ${domain}`);
+      deployments = await this.hosting_listJsDeployments_fetchDeployments(username, domain, queryParams);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.log('error', `Failed to fetch deployments: ${errorMessage}`);
+      throw error;
+    }
+
+    return {
+      status: 'success',
+      domain,
+      username,
+      queryParams: {
+        page,
+        perPage,
+        states
+      },
+      deployments
+    };
+  }
+
+  private hosting_showJsDeploymentLogs_validateRequiredParams(params: Record<string, any>): void {
+    const { domain, buildUuid, fromLine } = params;
+
+    if (!domain || typeof domain !== 'string') {
+      throw new Error('domain is required and must be a string');
+    }
+
+    if (!buildUuid || typeof buildUuid !== 'string') {
+      throw new Error('buildUuid is required and must be a string');
+    }
+
+    if (fromLine !== undefined && (typeof fromLine !== 'number' || !Number.isInteger(fromLine) || fromLine < 0)) {
+      throw new Error('fromLine must be a non-negative integer when provided');
+    }
+  }
+
+  private hosting_showJsDeploymentLogs_buildQueryParams(params: Record<string, any>): string {
+    const { fromLine } = params;
+    const queryParams = new URLSearchParams();
+
+    const line = (typeof fromLine === 'number' && Number.isInteger(fromLine) && fromLine >= 0) ? fromLine : 0;
+    queryParams.append('from_line', line.toString());
+
+    return queryParams.toString();
+  }
+
+  private async hosting_showJsDeploymentLogs_fetchLogs(username: string, domain: string, buildUuid: string, queryParams: string): Promise<any> {
     const baseUrl = this.baseUrl.endsWith("/") ? this.baseUrl : `${this.baseUrl}/`;
-    const url = new URL(`api/hosting/v1/accounts/${username}/websites/${domain}/nodejs/builds`, baseUrl).toString();
+    const url = new URL(`api/hosting/v1/accounts/${username}/websites/${domain}/nodejs/builds/${buildUuid}/logs`, baseUrl).toString();
+
+    const fullUrl = queryParams ? `${url}?${queryParams}` : url;
 
     try {
       const bearerToken = await this.getAuthToken();
 
-      const archiveBasename = path.basename(archivePath);
-      const buildData = {
-        ...buildSettings,
-        node_version: buildSettings?.node_version || 20,
-        source_type: 'archive',
-        source_options: {
-          archive_path: archiveBasename
-        }
-      };
-
       const config: AxiosRequestConfig = {
-        method: 'post',
-        url,
+        method: 'get',
+        url: fullUrl,
         headers: {
           ...this.headers,
-          'Authorization': `Bearer ${bearerToken}`,
-          'Content-Type': 'application/json'
+          'Authorization': `Bearer ${bearerToken}`
         },
-        data: buildData,
-        timeout: 60000, // 60s
+        timeout: 60000,
         validateStatus: function (status: number): boolean {
           return status < 500;
         }
@@ -1967,12 +2648,12 @@ class MCPServer {
         throw new Error(`API returned status ${response.status}: ${JSON.stringify(response.data)}`);
       }
 
-      this.log('info', `Successfully triggered build for ${domain}`);
+      this.log('info', `Successfully fetched logs for ${domain} build ${buildUuid}`);
       return response.data;
 
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      this.log('error', `Failed to trigger build: ${errorMessage}`);
+      this.log('error', `Failed to fetch logs: ${errorMessage}`);
 
       if (axios.isAxiosError(error)) {
         const responseData = error.response?.data;
@@ -1987,149 +2668,51 @@ class MCPServer {
     }
   }
 
-  private async handleJavascriptApplicationDeploy(params: Record<string, any>): Promise<any> {
-    const { domain, archivePath, removeArchive = false } = params;
+  private async handleShowJsDeploymentLogs(params: Record<string, any>): Promise<any> {
+    const { domain, buildUuid, fromLine } = params;
 
-    this.hosting_deployJsApplication_validateRequiredParams(params);
-    this.hosting_deployJsApplication_validateArchiveFile(archivePath);
+    this.hosting_showJsDeploymentLogs_validateRequiredParams(params);
 
-    // Auto-resolve username from domain
     this.log('info', `Resolving username from domain: ${domain}`);
     const username = await this.resolveUsername(domain);
 
-    // Upload archive file
-    this.log('info', `Starting archive upload for ${domain}`);
-    
-    let uploadCredentials: any;
-    try {
-      uploadCredentials = await this.fetchUploadCredentials(username, domain);
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      throw new Error(`Failed to fetch upload credentials: ${errorMessage}`);
-    }
-
-    const { url: uploadUrl, auth_key: authToken, rest_auth_key: authRestToken } = uploadCredentials;
-
-    if (!uploadUrl || !authToken || !authRestToken) {
-      throw new Error('Invalid upload credentials received from API');
-    }
-
-    const archiveBasename = path.basename(archivePath);
-    let uploadResult: any;
-    try {
-      const stats = fs.statSync(archivePath);
-      uploadResult = await this.uploadFile(
-        archivePath,
-        archiveBasename,
-        uploadUrl,
-        authRestToken,
-        authToken
-      );
-
-      this.log('info', `Successfully uploaded archive: ${archiveBasename}`);
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      throw new Error(`Failed to upload archive: ${errorMessage}`);
-    }
-
-    // Fetch build settings
-    let buildSettings: any;
-    try {
-      this.log('info', `Fetching build settings for ${domain}`);
-      buildSettings = await this.hosting_deployJsApplication_fetchBuildSettings(username, domain, archivePath);
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      this.log('error', `Failed to fetch build settings: ${errorMessage}`);
-      const archiveRemoved = this.hosting_deployJsApplication_removeArchive(archivePath, removeArchive);
-
-      return {
-        upload: {
-          status: 'success',
-          data: {
-            filename: uploadResult.filename
-          }
-        },
-        resolveSettings: {
-          status: 'error',
-          error: errorMessage
-        },
-        build: {
-          status: 'skipped'
-        },
-        removeArchive: {
-          status: archiveRemoved ? 'success' : 'skipped'
-        }
-      };
-    }
+    const queryParams = this.hosting_showJsDeploymentLogs_buildQueryParams(params);
 
-    // Trigger build
-    let buildResult: any;
+    let logs: any;
     try {
-      this.log('info', `Triggering build for ${domain}`);
-      buildResult = await this.hosting_deployJsApplication_triggerBuild(username, domain, archivePath, buildSettings);
+      this.log('info', `Fetching logs for ${domain}, build ${buildUuid}`);
+      logs = await this.hosting_showJsDeploymentLogs_fetchLogs(username, domain, buildUuid, queryParams);
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      this.log('error', `Failed to trigger build: ${errorMessage}`);
-      const archiveRemoved = this.hosting_deployJsApplication_removeArchive(archivePath, removeArchive);
-
-      return {
-        upload: {
-          status: 'success',
-          data: {
-            filename: uploadResult.filename
-          }
-        },
-        resolveSettings: {
-          status: 'success',
-          data: buildSettings
-        },
-        build: {
-          status: 'error',
-          error: errorMessage
-        },
-        removeArchive: {
-          status: archiveRemoved ? 'success' : 'skipped'
-        }
-      };
+      this.log('error', `Failed to fetch logs: ${errorMessage}`);
+      throw error;
     }
 
-    const archiveRemoved = this.hosting_deployJsApplication_removeArchive(archivePath, removeArchive);
+    const effectiveFromLine = (typeof fromLine === 'number' && Number.isInteger(fromLine) && fromLine >= 0) ? fromLine : 0;
 
     return {
-      upload: {
-        status: 'success',
-        data: {
-          filename: uploadResult.filename
-        }
-      },
-      resolveSettings: {
-        status: 'success',
-        data: buildSettings
-      },
-      build: {
-        status: 'success',
-        data: buildResult
-      },
-      removeArchive: {
-        status: archiveRemoved ? 'success' : 'skipped'
-      }
-    };
-  }
-
-  private hosting_deployStaticWebsite_validateArchiveFormat(filePath: string): boolean {
-    const validExtensions = ['zip', 'tar', 'tar.gz', 'tgz', '7z', 'gz', 'gzip'];
-    const fileName = path.basename(filePath).toLowerCase();
-    
-    for (const ext of validExtensions) {
-      if (fileName.endsWith(`.${ext}`)) {
-        return true;
-      }
+      domain,
+      username,
+      buildUuid,
+      fromLine: effectiveFromLine,
+      logs
+    };
+  }
+
+  private agencyHosting_normalizePath(pathString: string): string {
+    return pathString.replace(/\\/g, '/');
+  }
+
+  private agencyHosting_generateUploadDir(): string {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    let result = '';
+    for (let i = 0; i < 12; i++) {
+      result += chars.charAt(Math.floor(Math.random() * chars.length));
     }
-    
-    return false;
+    return result;
   }
 
-  private hosting_deployStaticWebsite_validateRequiredParams(params: Record<string, any>): void {
+  private agencyHosting_validateRequiredParams(params: Record<string, any>): void {
     const { domain, archivePath, removeArchive } = params;
 
     if (!domain || typeof domain !== 'string') {
@@ -2145,7 +2728,18 @@ class MCPServer {
     }
   }
 
-  private hosting_deployStaticWebsite_removeArchive(archivePath: string, removeArchive: boolean): boolean {
+  private agencyHosting_validateArchiveFile(archivePath: string): void {
+    if (!fs.existsSync(archivePath)) {
+      throw new Error(`Archive file not found: ${archivePath}`);
+    }
+
+    const archiveStats = fs.statSync(archivePath);
+    if (!archiveStats.isFile()) {
+      throw new Error(`Archive path is not a file: ${archivePath}`);
+    }
+  }
+
+  private agencyHosting_removeArchive(archivePath: string, removeArchive: boolean): boolean {
     if (!removeArchive) {
       return false;
     }
@@ -2162,33 +2756,216 @@ class MCPServer {
     }
   }
 
-  private hosting_deployStaticWebsite_validateArchiveFile(archivePath: string): void {
-    if (!fs.existsSync(archivePath)) {
-      throw new Error(`Archive file not found: ${archivePath}`);
-    }
+  private async agencyHosting_resolveWebsiteUid(domain: string): Promise<string> {
+    const baseUrl = this.baseUrl.endsWith("/") ? this.baseUrl : `${this.baseUrl}/`;
+    const perPage = 100;
 
-    const archiveStats = fs.statSync(archivePath);
-    if (!archiveStats.isFile()) {
-      throw new Error(`Archive path is not a file: ${archivePath}`);
-    }
+    try {
+      const bearerToken = await this.getAuthToken();
+      let page = 1;
+      let total = 0;
 
-    if (!this.hosting_deployStaticWebsite_validateArchiveFormat(archivePath)) {
-      throw new Error('Invalid archive format. Supported formats: zip, tar, tar.gz, tgz, 7z, gz, gzip');
+      do {
+        const url = new URL(
+          `api/agency-hosting/v1/domains?page=${page}&per_page=${perPage}`,
+          baseUrl
+        ).toString();
+
+        const config: AxiosRequestConfig = {
+          method: 'get',
+          url,
+          headers: {
+            ...this.headers,
+            'Authorization': `Bearer ${bearerToken}`
+          },
+          timeout: 60000, // 60s
+          validateStatus: function (status: number): boolean {
+            return status < 500;
+          }
+        };
+
+        const response = await axios(config);
+
+        if (response.status !== 200) {
+          throw new Error(`API returned status ${response.status}: ${JSON.stringify(response.data)}`);
+        }
+
+        const domains = response.data?.data ?? [];
+        const match = domains.find((item: any) => item.fqdn === domain);
+        if (match?.website_uid) {
+          this.log('info', `Resolved website UID: ${match.website_uid} for domain: ${domain}`);
+          return match.website_uid;
+        }
+
+        total = response.data?.meta?.total ?? domains.length;
+        page++;
+      } while ((page - 1) * perPage < total);
+
+      throw new Error(`No Agency Plan website found for domain: ${domain}`);
+
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.log('error', `Failed to resolve website UID for domain ${domain}: ${errorMessage}`);
+
+      if (axios.isAxiosError(error)) {
+        const responseData = error.response?.data;
+        const responseStatus = error.response?.status;
+        this.log('error', 'API Error Details:', {
+          status: responseStatus,
+          data: typeof responseData === 'object' ? JSON.stringify(responseData) : responseData
+        });
+      }
+
+      throw error;
     }
   }
 
-  private async hosting_deployStaticWebsite_triggerDeploy(username: string, domain: string, archivePath: string): Promise<any> {
+  private async agencyHosting_fetchUploadCredentials(
+    websiteUid: string
+  ): Promise<{ url: string; auth_key: string; rest_auth_key: string }> {
     const baseUrl = this.baseUrl.endsWith("/") ? this.baseUrl : `${this.baseUrl}/`;
-    const url = new URL(`api/hosting/v1/accounts/${username}/websites/${domain}/deploy`, baseUrl).toString();
+    const url = new URL(`api/agency-hosting/v1/websites/${websiteUid}/files/upload-urls`, baseUrl).toString();
 
     try {
       const bearerToken = await this.getAuthToken();
 
-      const archiveBasename = path.basename(archivePath);
-      const deployData = {
-        archive_path: archiveBasename
+      const config: AxiosRequestConfig = {
+        method: 'post',
+        url,
+        headers: {
+          ...this.headers,
+          'Authorization': `Bearer ${bearerToken}`,
+          'Content-Type': 'application/json'
+        },
+        timeout: 60000, // 60s
+        validateStatus: function (status: number): boolean {
+          return status < 500;
+        }
       };
 
+      const response = await axios(config);
+
+      if (response.status !== 200) {
+        throw new Error(`API returned status ${response.status}: ${JSON.stringify(response.data)}`);
+      }
+
+      return response.data;
+
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.log('error', `Failed to fetch upload credentials: ${errorMessage}`);
+
+      if (axios.isAxiosError(error)) {
+        const responseData = error.response?.data;
+        const responseStatus = error.response?.status;
+        this.log('error', 'API Error Details:', {
+          status: responseStatus,
+          data: typeof responseData === 'object' ? JSON.stringify(responseData) : responseData
+        });
+      }
+
+      throw error;
+    }
+  }
+
+  private async agencyHosting_uploadFile(
+    filePath: string,
+    relativePath: string,
+    uploadUrl: string,
+    authRestToken: string,
+    authToken: string
+  ): Promise<{ url: string; filename: string }> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const stats = fs.statSync(filePath);
+        const fileStream = fs.createReadStream(filePath);
+
+        const cleanUploadUrl = uploadUrl.replace(new RegExp('/$'), '');
+        const normalizedPath = this.agencyHosting_normalizePath(relativePath);
+        const uploadUrlWithFile = `${cleanUploadUrl}/${normalizedPath}?override=true`;
+
+        const requestHeaders: Record<string, string> = {
+          'X-Auth': authToken,
+          'X-Auth-Rest': authRestToken,
+          'upload-length': stats.size.toString(),
+          'upload-offset': '0'
+        };
+
+        try {
+          this.log('debug', `Making pre-upload POST request to ${uploadUrlWithFile}`);
+          await axios.post(uploadUrlWithFile, '', {
+            headers: requestHeaders,
+            timeout: 60000, // 60s
+            validateStatus: function (status: number): boolean {
+              return status == 201;
+            }
+          });
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+
+          if (axios.isAxiosError(error)) {
+            const responseData = error.response?.data;
+            const responseStatus = error.response?.status;
+            const responseHeaders = error.response?.headers;
+            const responseText = typeof responseData === 'object' ? JSON.stringify(responseData) : responseData;
+
+            this.log('error', 'Pre-upload POST request failed - Full Response Details:', {
+              status: responseStatus,
+              headers: responseHeaders,
+              data: responseText,
+              message: errorMessage
+            });
+            reject(new Error(`Pre-upload request failed: ${errorMessage}`));
+            return;
+          } else {
+            this.log('error', `Pre-upload POST request failed: ${errorMessage}`);
+            reject(new Error(`Pre-upload request failed: ${errorMessage}`));
+            return;
+          }
+        }
+
+        const upload = new tus.Upload(fileStream, {
+          uploadUrl: uploadUrlWithFile,
+          retryDelays: [1000, 2000, 4000, 8000, 16000, 20000],
+          uploadDataDuringCreation: false,
+          parallelUploads: 1,
+          chunkSize: 10485760,
+          headers: requestHeaders,
+          removeFingerprintOnSuccess: true,
+          uploadSize: stats.size,
+          metadata: {
+            filename: path.basename(relativePath)
+          },
+          onError: (error: Error) => {
+            this.log('error', `TUS upload error for ${relativePath}`, { error: error.message });
+            reject(new Error(`Upload failed: ${error.message}`));
+          },
+          onSuccess: () => {
+            this.log('info', `TUS upload completed for ${relativePath}`, { url: upload.url });
+            resolve({
+              url: upload.url || uploadUrlWithFile,
+              filename: relativePath
+            });
+          }
+        });
+
+        upload.start();
+
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        this.log('error', `Error preparing upload for ${filePath}`, { error: errorMessage });
+        reject(new Error(`Failed to prepare upload: ${errorMessage}`));
+      }
+    });
+  }
+
+  private async agencyHosting_deployNodeStatic_triggerBuildAssets(websiteUid: string, archivePath: string): Promise<any> {
+    const baseUrl = this.baseUrl.endsWith("/") ? this.baseUrl : `${this.baseUrl}/`;
+    const url = new URL(`api/agency-hosting/v1/websites/${websiteUid}/build-assets`, baseUrl).toString();
+
+    try {
+      const bearerToken = await this.getAuthToken();
+
       const config: AxiosRequestConfig = {
         method: 'post',
         url,
@@ -2197,7 +2974,9 @@ class MCPServer {
           'Authorization': `Bearer ${bearerToken}`,
           'Content-Type': 'application/json'
         },
-        data: deployData,
+        data: {
+          archive_path: archivePath
+        },
         timeout: 60000,
         validateStatus: function (status: number): boolean {
           return status < 500;
@@ -2206,16 +2985,16 @@ class MCPServer {
 
       const response = await axios(config);
 
-      if (response.status !== 200) {
+      if (response.status < 200 || response.status >= 300) {
         throw new Error(`API returned status ${response.status}: ${JSON.stringify(response.data)}`);
       }
 
-      this.log('info', `Successfully triggered deployment for ${domain}`);
+      this.log('info', `Successfully triggered build for website ${websiteUid}`);
       return response.data;
 
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      this.log('error', `Failed to trigger deployment: ${errorMessage}`);
+      this.log('error', `Failed to trigger build: ${errorMessage}`);
 
       if (axios.isAxiosError(error)) {
         const responseData = error.response?.data;
@@ -2230,20 +3009,20 @@ class MCPServer {
     }
   }
 
-  private async handleStaticWebsiteDeploy(params: Record<string, any>): Promise<any> {
-    const { domain, archivePath, removeArchive = false } = params;
-
-    this.hosting_deployStaticWebsite_validateRequiredParams(params);
-    this.hosting_deployStaticWebsite_validateArchiveFile(archivePath);
+  private async handleNodeStaticDeploy(params: Record<string, any>): Promise<any> {
+    const { domain, archivePath, removeArchive = true } = params;
 
-    this.log('info', `Resolving username from domain: ${domain}`);
-    const username = await this.resolveUsername(domain);
+    this.agencyHosting_validateRequiredParams(params);
+    this.agencyHosting_validateArchiveFile(archivePath);
+
+    this.log('info', `Resolving website UID from domain: ${domain}`);
+    const websiteUid = await this.agencyHosting_resolveWebsiteUid(domain);
 
     this.log('info', `Starting archive upload for ${domain}`);
-    
+
     let uploadCredentials: any;
     try {
-      uploadCredentials = await this.fetchUploadCredentials(username, domain);
+      uploadCredentials = await this.agencyHosting_fetchUploadCredentials(websiteUid);
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       throw new Error(`Failed to fetch upload credentials: ${errorMessage}`);
@@ -2256,12 +3035,12 @@ class MCPServer {
     }
 
     const archiveBasename = path.basename(archivePath);
+    const uploadDir = `.h5g/${this.agencyHosting_generateUploadDir()}`;
     let uploadResult: any;
     try {
-      const stats = fs.statSync(archivePath);
-      uploadResult = await this.uploadFile(
+      uploadResult = await this.agencyHosting_uploadFile(
         archivePath,
-        archiveBasename,
+        `${uploadDir}/${archiveBasename}`,
         uploadUrl,
         authRestToken,
         authToken
@@ -2275,12 +3054,12 @@ class MCPServer {
 
     let deployResult: any;
     try {
-      this.log('info', `Triggering deployment for ${domain}`);
-      deployResult = await this.hosting_deployStaticWebsite_triggerDeploy(username, domain, archivePath);
+      this.log('info', `Triggering build for ${domain}`);
+      deployResult = await this.agencyHosting_deployNodeStatic_triggerBuildAssets(websiteUid, uploadDir);
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      this.log('error', `Failed to trigger deployment: ${errorMessage}`);
-      const archiveRemoved = this.hosting_deployStaticWebsite_removeArchive(archivePath, removeArchive);
+      this.log('error', `Failed to trigger build: ${errorMessage}`);
+      const archiveRemoved = this.agencyHosting_removeArchive(archivePath, removeArchive);
 
       return {
         upload: {
@@ -2299,7 +3078,7 @@ class MCPServer {
       };
     }
 
-    const archiveRemoved = this.hosting_deployStaticWebsite_removeArchive(archivePath, removeArchive);
+    const archiveRemoved = this.agencyHosting_removeArchive(archivePath, removeArchive);
 
     return {
       upload: {
@@ -2318,52 +3097,25 @@ class MCPServer {
     };
   }
 
-  private hosting_listJsDeployments_validateRequiredParams(params: Record<string, any>): void {
-    const { domain } = params;
-
-    if (!domain || typeof domain !== 'string') {
-      throw new Error('domain is required and must be a string');
-    }
-  }
-
-  private hosting_listJsDeployments_buildQueryParams(params: Record<string, any>): string {
-    const { page, perPage, states } = params;
-    const queryParams = new URLSearchParams();
-
-    if (page !== undefined && page !== null) {
-      queryParams.append('page', page.toString());
-    }
-
-    if (perPage !== undefined && perPage !== null) {
-      queryParams.append('per_page', perPage.toString());
-    }
-
-    if (states && Array.isArray(states) && states.length > 0) {
-      states.forEach(state => {
-        queryParams.append('states[]', state);
-      });
-    }
-
-    return queryParams.toString();
-  }
-
-  private async hosting_listJsDeployments_fetchDeployments(username: string, domain: string, queryParams: string): Promise<any> {
+  private async agencyHosting_deployPhpApp_triggerImportArchive(websiteUid: string, archiveName: string): Promise<any> {
     const baseUrl = this.baseUrl.endsWith("/") ? this.baseUrl : `${this.baseUrl}/`;
-    const url = new URL(`api/hosting/v1/accounts/${username}/websites/${domain}/nodejs/builds`, baseUrl).toString();
-    
-    const fullUrl = queryParams ? `${url}?${queryParams}` : url;
+    const url = new URL(`api/agency-hosting/v1/websites/${websiteUid}/files/import-archive`, baseUrl).toString();
 
     try {
       const bearerToken = await this.getAuthToken();
 
       const config: AxiosRequestConfig = {
-        method: 'get',
-        url: fullUrl,
+        method: 'post',
+        url,
         headers: {
           ...this.headers,
-          'Authorization': `Bearer ${bearerToken}`
+          'Authorization': `Bearer ${bearerToken}`,
+          'Content-Type': 'application/json'
         },
-        timeout: 60000, // 60s
+        data: {
+          archive_name: archiveName
+        },
+        timeout: 60000,
         validateStatus: function (status: number): boolean {
           return status < 500;
         }
@@ -2371,16 +3123,16 @@ class MCPServer {
 
       const response = await axios(config);
 
-      if (response.status !== 200) {
+      if (response.status < 200 || response.status >= 300) {
         throw new Error(`API returned status ${response.status}: ${JSON.stringify(response.data)}`);
       }
 
-      this.log('info', `Successfully fetched deployments for ${domain}`);
+      this.log('info', `Successfully triggered import for website ${websiteUid}`);
       return response.data;
 
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      this.log('error', `Failed to fetch deployments: ${errorMessage}`);
+      this.log('error', `Failed to trigger import: ${errorMessage}`);
 
       if (axios.isAxiosError(error)) {
         const responseData = error.response?.data;
@@ -2395,144 +3147,90 @@ class MCPServer {
     }
   }
 
-  private async handleListJavascriptDeployments(params: Record<string, any>): Promise<any> {
-    const { domain, page, perPage, states } = params;
+  private async handlePhpAppDeploy(params: Record<string, any>): Promise<any> {
+    const { domain, archivePath, removeArchive = true } = params;
 
-    this.hosting_listJsDeployments_validateRequiredParams(params);
+    this.agencyHosting_validateRequiredParams(params);
+    this.agencyHosting_validateArchiveFile(archivePath);
 
-    // Auto-resolve username from domain
-    this.log('info', `Resolving username from domain: ${domain}`);
-    const username = await this.resolveUsername(domain);
+    this.log('info', `Resolving website UID from domain: ${domain}`);
+    const websiteUid = await this.agencyHosting_resolveWebsiteUid(domain);
 
-    // Build query parameters
-    const queryParams = this.hosting_listJsDeployments_buildQueryParams(params);
+    this.log('info', `Starting archive upload for ${domain}`);
 
-    // Fetch deployments
-    let deployments: any;
+    let uploadCredentials: any;
     try {
-      this.log('info', `Fetching deployments for ${domain}`);
-      deployments = await this.hosting_listJsDeployments_fetchDeployments(username, domain, queryParams);
+      uploadCredentials = await this.agencyHosting_fetchUploadCredentials(websiteUid);
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      this.log('error', `Failed to fetch deployments: ${errorMessage}`);
-      throw error;
-    }
-
-    return {
-      status: 'success',
-      domain,
-      username,
-      queryParams: {
-        page,
-        perPage,
-        states
-      },
-      deployments
-    };
-  }
-
-  private hosting_showJsDeploymentLogs_validateRequiredParams(params: Record<string, any>): void {
-    const { domain, buildUuid, fromLine } = params;
-
-    if (!domain || typeof domain !== 'string') {
-      throw new Error('domain is required and must be a string');
+      throw new Error(`Failed to fetch upload credentials: ${errorMessage}`);
     }
 
-    if (!buildUuid || typeof buildUuid !== 'string') {
-      throw new Error('buildUuid is required and must be a string');
-    }
+    const { url: uploadUrl, auth_key: authToken, rest_auth_key: authRestToken } = uploadCredentials;
 
-    if (fromLine !== undefined && (typeof fromLine !== 'number' || !Number.isInteger(fromLine) || fromLine < 0)) {
-      throw new Error('fromLine must be a non-negative integer when provided');
+    if (!uploadUrl || !authToken || !authRestToken) {
+      throw new Error('Invalid upload credentials received from API');
     }
-  }
-
-  private hosting_showJsDeploymentLogs_buildQueryParams(params: Record<string, any>): string {
-    const { fromLine } = params;
-    const queryParams = new URLSearchParams();
-
-    const line = (typeof fromLine === 'number' && Number.isInteger(fromLine) && fromLine >= 0) ? fromLine : 0;
-    queryParams.append('from_line', line.toString());
-
-    return queryParams.toString();
-  }
-
-  private async hosting_showJsDeploymentLogs_fetchLogs(username: string, domain: string, buildUuid: string, queryParams: string): Promise<any> {
-    const baseUrl = this.baseUrl.endsWith("/") ? this.baseUrl : `${this.baseUrl}/`;
-    const url = new URL(`api/hosting/v1/accounts/${username}/websites/${domain}/nodejs/builds/${buildUuid}/logs`, baseUrl).toString();
-
-    const fullUrl = queryParams ? `${url}?${queryParams}` : url;
 
+    const archiveBasename = path.basename(archivePath);
+    let uploadResult: any;
     try {
-      const bearerToken = await this.getAuthToken();
-
-      const config: AxiosRequestConfig = {
-        method: 'get',
-        url: fullUrl,
-        headers: {
-          ...this.headers,
-          'Authorization': `Bearer ${bearerToken}`
-        },
-        timeout: 60000,
-        validateStatus: function (status: number): boolean {
-          return status < 500;
-        }
-      };
-
-      const response = await axios(config);
-
-      if (response.status !== 200) {
-        throw new Error(`API returned status ${response.status}: ${JSON.stringify(response.data)}`);
-      }
-
-      this.log('info', `Successfully fetched logs for ${domain} build ${buildUuid}`);
-      return response.data;
+      uploadResult = await this.agencyHosting_uploadFile(
+        archivePath,
+        `.h5g/${archiveBasename}`,
+        uploadUrl,
+        authRestToken,
+        authToken
+      );
 
+      this.log('info', `Successfully uploaded archive: ${archiveBasename}`);
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      this.log('error', `Failed to fetch logs: ${errorMessage}`);
-
-      if (axios.isAxiosError(error)) {
-        const responseData = error.response?.data;
-        const responseStatus = error.response?.status;
-        this.log('error', 'API Error Details:', {
-          status: responseStatus,
-          data: typeof responseData === 'object' ? JSON.stringify(responseData) : responseData
-        });
-      }
-
-      throw error;
+      throw new Error(`Failed to upload archive: ${errorMessage}`);
     }
-  }
-
-  private async handleShowJsDeploymentLogs(params: Record<string, any>): Promise<any> {
-    const { domain, buildUuid, fromLine } = params;
-
-    this.hosting_showJsDeploymentLogs_validateRequiredParams(params);
-
-    this.log('info', `Resolving username from domain: ${domain}`);
-    const username = await this.resolveUsername(domain);
 
-    const queryParams = this.hosting_showJsDeploymentLogs_buildQueryParams(params);
-
-    let logs: any;
+    let deployResult: any;
     try {
-      this.log('info', `Fetching logs for ${domain}, build ${buildUuid}`);
-      logs = await this.hosting_showJsDeploymentLogs_fetchLogs(username, domain, buildUuid, queryParams);
+      this.log('info', `Triggering import for ${domain}`);
+      deployResult = await this.agencyHosting_deployPhpApp_triggerImportArchive(websiteUid, archiveBasename);
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      this.log('error', `Failed to fetch logs: ${errorMessage}`);
-      throw error;
+      this.log('error', `Failed to trigger import: ${errorMessage}`);
+      const archiveRemoved = this.agencyHosting_removeArchive(archivePath, removeArchive);
+
+      return {
+        upload: {
+          status: 'success',
+          data: {
+            filename: uploadResult.filename
+          }
+        },
+        deploy: {
+          status: 'error',
+          error: errorMessage
+        },
+        removeArchive: {
+          status: archiveRemoved ? 'success' : 'skipped'
+        }
+      };
     }
 
-    const effectiveFromLine = (typeof fromLine === 'number' && Number.isInteger(fromLine) && fromLine >= 0) ? fromLine : 0;
+    const archiveRemoved = this.agencyHosting_removeArchive(archivePath, removeArchive);
 
     return {
-      domain,
-      username,
-      buildUuid,
-      fromLine: effectiveFromLine,
-      logs
+      upload: {
+        status: 'success',
+        data: {
+          filename: uploadResult.filename
+        }
+      },
+      deploy: {
+        status: 'success',
+        data: deployResult
+      },
+      removeArchive: {
+        status: archiveRemoved ? 'success' : 'skipped'
+      }
     };
   }