servyx-cli 0.1.10 → 0.1.12

package/README.md

@@ -61,9 +61,6 @@ servyx status
 - Project config: `servyx.json` in your project root
 - Optional excludes: `.servyxignore` (rsync patterns). By default, hidden files (`.env`, `.htaccess`, etc.) are not uploaded and existing server copies are preserved. Use `servyx deploy --with-env` to upload local `.env` / `.env.*` files (useful for React/Vite builds).
 
-Environment variables:
-
-- `SERVYX_API_URL` — override CLI service base URL
 
 ## How it works
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "servyx-cli",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "Servyx CLI — Upload local projects and deploy via the Servyx platform",
   "type": "module",
   "bin": {

package/src/commands/deploy.js

@@ -1,5 +1,5 @@
 import pc from 'picocolors';
-import { getDeployTarget, getDeployment, startDeployment } from '../lib/api.js';
+import { getDeployTarget, getDeployment, startDeployment, setApiVerbose } from '../lib/api.js';
 import { getToken } from '../lib/config.js';
 import { loadProjectConfig, loadServyxIgnore } from '../lib/project.js';
 import { rsyncDeploy, sshPreflight, DEFAULT_RSYNC_EXCLUDES, preserveServerDotfiles, ensureRemoteDir, verifyRemoteStagingDir } from '../lib/rsync.js';
@@ -18,6 +18,8 @@ function formatDeploymentLine(deployment) {
 }
 
 export async function runDeploy(options = {}) {
+  setApiVerbose(Boolean(options.verbose));
+
   if (!getToken()) {
     console.error(pc.red('Not logged in. Run: servyx login'));
     process.exit(1);
@@ -150,7 +152,7 @@ export async function runDeploy(options = {}) {
   console.log(pc.dim(`Deployment ID: ${deploymentId}`));
 
   while (true) {
-    const statusResult = await getDeployment(deploymentId);
+    const statusResult = await getDeployment(appId, deploymentId);
     const current = statusResult?.data?.deployment;
     if (!current) {
       console.error(pc.red('Deployment not found while polling.'));

package/src/index.js

@@ -47,9 +47,10 @@ program
   .description('Rsync local files and trigger a deployment')
   .option('-m, --message <message>', 'Deployment message')
   .option('--with-env', 'Upload local .env files (for React/Vite frontends)')
+  .option('-v, --verbose', 'Log API requests and responses')
   .action(async (options) => {
     try {
-      await runDeploy({ ...options, withEnv: Boolean(options.withEnv) });
+      await runDeploy({ ...options, withEnv: Boolean(options.withEnv), verbose: Boolean(options.verbose) });
     } catch (err) {
       console.error(pc.red(err.message || 'Deploy failed'));
       process.exit(1);

package/src/lib/api.js

@@ -1,9 +1,134 @@
 import axios from 'axios';
+import pc from 'picocolors';
 import { getApiBaseUrl, getToken } from './config.js';
 
+let apiVerbose = false;
+
+export function setApiVerbose(enabled) {
+  apiVerbose = Boolean(enabled);
+}
+
+function isApiVerbose() {
+  return apiVerbose || process.env.SERVYX_DEBUG === '1' || process.env.SERVYX_DEBUG === 'true';
+}
+
+function buildFullUrl(baseURL = '', url = '') {
+  const base = String(baseURL).replace(/\/+$/, '');
+  const path = String(url).replace(/^\//, '');
+  return path ? `${base}/${path}` : base;
+}
+
+function summarizeBody(data) {
+  if (data == null) return '(empty)';
+  if (typeof data === 'string') {
+    const trimmed = data.trim();
+    if (!trimmed) return '(empty)';
+    if (trimmed.length > 800) {
+      return `${trimmed.slice(0, 800)}... [truncated, ${trimmed.length} chars]`;
+    }
+    return trimmed;
+  }
+  try {
+    const text = JSON.stringify(data);
+    if (text.length > 1200) {
+      return `${text.slice(0, 1200)}... [truncated]`;
+    }
+    return text;
+  } catch {
+    return String(data);
+  }
+}
+
+function logApiRequest(config) {
+  const method = config.method?.toUpperCase() || 'REQUEST';
+  const url = config._servyxFullUrl || buildFullUrl(config.baseURL, config.url);
+  console.error(pc.dim(`→ ${method} ${url}`));
+  if (config.params && Object.keys(config.params).length) {
+    console.error(pc.dim(`  Query: ${summarizeBody(config.params)}`));
+  }
+  if (config.data != null) {
+    console.error(pc.dim(`  Body: ${summarizeBody(config.data)}`));
+  }
+}
+
+function logApiResponse(response) {
+  const method = response.config?.method?.toUpperCase() || 'REQUEST';
+  const url = response.config?._servyxFullUrl || buildFullUrl(response.config?.baseURL, response.config?.url);
+  const elapsed = response.config?._servyxStart
+    ? `${Date.now() - response.config._servyxStart}ms`
+    : '';
+  console.error(pc.dim(`← ${response.status} ${method} ${url}${elapsed ? ` (${elapsed})` : ''}`));
+  if (isApiVerbose()) {
+    console.error(pc.dim(`  Response: ${summarizeBody(response.data)}`));
+  }
+}
+
+export function logApiError({ method = 'REQUEST', url = 'unknown', err = null, response = null } = {}) {
+  console.error(pc.yellow('--- Servyx API error ---'));
+  console.error(pc.dim(`${method} ${url}`));
+  console.error(pc.dim(`API base: ${getApiBaseUrl()}`));
+
+  if (response) {
+    console.error(pc.dim(`Status: ${response.status} ${response.statusText || ''}`));
+    const headers = response.headers || {};
+    const contentType = headers['content-type'] || headers['Content-Type'];
+    if (contentType) {
+      console.error(pc.dim(`Content-Type: ${contentType}`));
+    }
+    console.error(pc.dim(`Response body: ${summarizeBody(response.data)}`));
+  }
+
+  if (err) {
+    if (err.code) console.error(pc.dim(`Network code: ${err.code}`));
+    if (err.syscall) console.error(pc.dim(`Syscall: ${err.syscall}`));
+    if (err.errno != null) console.error(pc.dim(`Errno: ${err.errno}`));
+    if (err.address) console.error(pc.dim(`Address: ${err.address}${err.port ? `:${err.port}` : ''}`));
+    if (err.message) console.error(pc.dim(`Message: ${err.message}`));
+    if (err.config && !response) {
+      const reqUrl = err.config._servyxFullUrl || buildFullUrl(err.config.baseURL, err.config.url);
+      console.error(pc.dim(`Request: ${err.config.method?.toUpperCase() || 'REQUEST'} ${reqUrl}`));
+      if (err.config.data != null) {
+        console.error(pc.dim(`Request body: ${summarizeBody(err.config.data)}`));
+      }
+    }
+  }
+
+  console.error(pc.yellow('------------------------'));
+}
+
+function attachLogging(client) {
+  client.interceptors.request.use((config) => {
+    config._servyxStart = Date.now();
+    config._servyxFullUrl = buildFullUrl(config.baseURL, config.url);
+    if (isApiVerbose()) {
+      logApiRequest(config);
+    }
+    return config;
+  });
+
+  client.interceptors.response.use(
+    (response) => {
+      if (isApiVerbose()) {
+        logApiResponse(response);
+      }
+      return response;
+    },
+    (error) => {
+      const config = error.config || {};
+      logApiError({
+        method: config.method?.toUpperCase() || 'REQUEST',
+        url: config._servyxFullUrl || buildFullUrl(config.baseURL, config.url),
+        err: error,
+        response: error.response || null,
+      });
+      return Promise.reject(error);
+    },
+  );
+}
+
 function createClient(token = getToken()) {
   const baseURL = `${getApiBaseUrl()}/api/v1/cli`;
-  return axios.create({
+  const client = axios.create({
     baseURL,
     timeout: 120000,
     headers: {
@@ -12,11 +137,20 @@ function createClient(token = getToken()) {
     },
     validateStatus: () => true,
   });
+  attachLogging(client);
+  return client;
 }
 
-function mapNetworkError(err, action = 'request') {
+function mapNetworkError(err, meta = {}) {
   if (err?.response || err?.status) throw err;
-  if (['ECONNRESET', 'ECONNREFUSED', 'ENOTFOUND', 'ETIMEDOUT'].includes(err?.code)) {
+  if (['ECONNRESET', 'ECONNREFUSED', 'ENOTFOUND', 'ETIMEDOUT', 'ECONNABORTED'].includes(err?.code)) {
+    if (!err?.config) {
+      logApiError({
+        method: meta.method || 'REQUEST',
+        url: meta.url || `${getApiBaseUrl()}/api/v1/cli${meta.path || ''}`,
+        err,
+      });
+    }
     const hint = new Error(
       `Cannot reach Servyx API at ${getApiBaseUrl()} (${err.code}). Is cli-service running?`,
     );
@@ -30,7 +164,17 @@ function unwrap(response) {
   if (response.status >= 200 && response.status < 300) {
     return response.data;
   }
-  const err = new Error(response.data?.error || response.statusText || 'Request failed');
+
+  const method = response.config?.method?.toUpperCase() || 'REQUEST';
+  const url = response.config?._servyxFullUrl || buildFullUrl(response.config?.baseURL, response.config?.url);
+  logApiError({ method, url, response });
+
+  const isHtml = typeof response.data === 'string' && response.data.includes('<html');
+  const message = isHtml
+    ? `API returned ${response.status} (expected JSON). Check SERVYX_API_URL / cli-service routing.`
+    : (response.data?.error || response.data?.message || response.statusText || 'Request failed');
+
+  const err = new Error(message);
   err.status = response.status;
   err.code = response.data?.code;
   err.data = response.data;
@@ -40,6 +184,7 @@ function unwrap(response) {
 export async function login({ username, password, otp, apiUrl }) {
   const baseURL = `${(apiUrl || getApiBaseUrl()).replace(/\/+$/, '')}/api/v1/cli`;
   const client = axios.create({ baseURL, timeout: 60000, validateStatus: () => true });
+  attachLogging(client);
   const response = await client.post('/auth/login', { username, password, otp });
   return unwrap(response);
 }
@@ -55,20 +200,26 @@ export async function getDeployTarget(appId) {
 }
 
 export async function startDeployment(appId, message, { withEnv = false } = {}) {
+  const path = `/apps/${appId}/deployments`;
+  const body = {
+    message,
+    with_env: withEnv || undefined,
+  };
   try {
     const client = createClient();
-    return unwrap(await client.post(`/apps/${appId}/deployments`, {
-      message,
-      with_env: withEnv || undefined,
-    }));
+    return unwrap(await client.post(path, body));
   } catch (err) {
-    mapNetworkError(err, 'start deployment');
+    mapNetworkError(err, {
+      method: 'POST',
+      path,
+      url: buildFullUrl(`${getApiBaseUrl()}/api/v1/cli`, path),
+    });
   }
 }
 
-export async function getDeployment(deploymentId) {
+export async function getDeployment(appId, deploymentId) {
   const client = createClient();
-  return unwrap(await client.get(`/deployments/${deploymentId}`));
+  return unwrap(await client.get(`/apps/${appId}/deployments/${deploymentId}`));
 }
 
 export async function listAppDeployments(appId, limit = 10) {