servyx-cli 0.1.11 → 0.1.13

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.11",
+  "version": "0.1.13",
   "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);

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,24 +1,186 @@
 import axios from 'axios';
+import pc from 'picocolors';
 import { getApiBaseUrl, getToken } from './config.js';
 
-function createClient(token = getToken()) {
+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);
+    },
+  );
+}
+
+const START_DEPLOY_TIMEOUT_MS = 180000;
+const NETWORK_RETRY_CODES = new Set(['ECONNRESET', 'ETIMEDOUT', 'ECONNABORTED']);
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function findRecentActiveDeployment(appId, maxAgeMs = 120000) {
+  try {
+    const client = createClient();
+    const response = await client.get(`/apps/${appId}/deployments`, { params: { limit: 5 } });
+    if (response.status < 200 || response.status >= 300) return null;
+
+    const deployments = response.data?.data?.deployments || [];
+    const cutoff = Date.now() - maxAgeMs;
+
+    return deployments.find((deployment) => {
+      if (!['pending', 'in_progress'].includes(deployment.status)) return false;
+      const createdAt = deployment.created_at ? new Date(deployment.created_at).getTime() : 0;
+      return createdAt >= cutoff;
+    }) || null;
+  } catch {
+    return null;
+  }
+}
+
+function createClient(token = getToken(), { timeout = 120000 } = {}) {
   const baseURL = `${getApiBaseUrl()}/api/v1/cli`;
-  return axios.create({
+  const client = axios.create({
     baseURL,
-    timeout: 120000,
+    timeout,
     headers: {
       'Content-Type': 'application/json',
       ...(token ? { Authorization: `Bearer ${token}` } : {}),
     },
     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?`,
+      err.code === 'ECONNRESET'
+        ? `Connection to ${getApiBaseUrl()} was reset (${err.code}). The deploy may still have started — retry status polling or check the dashboard. Common when redeploying cli-service itself.`
+        : `Cannot reach Servyx API at ${getApiBaseUrl()} (${err.code}). Is cli-service running?`,
     );
     hint.code = err.code;
     throw hint;
@@ -31,6 +193,10 @@ function unwrap(response) {
     return response.data;
   }
 
+  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.`
@@ -46,6 +212,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);
 }
@@ -61,14 +228,45 @@ 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,
+  };
+  const url = buildFullUrl(`${getApiBaseUrl()}/api/v1/cli`, path);
+  const client = createClient(undefined, { timeout: START_DEPLOY_TIMEOUT_MS });
+
+  const postDeploy = () => client.post(path, body);
+
   try {
-    const client = createClient();
-    return unwrap(await client.post(`/apps/${appId}/deployments`, {
-      message,
-      with_env: withEnv || undefined,
-    }));
+    return unwrap(await postDeploy());
   } catch (err) {
-    mapNetworkError(err, 'start deployment');
+    if (NETWORK_RETRY_CODES.has(err?.code)) {
+      await sleep(1500);
+      try {
+        return unwrap(await postDeploy());
+      } catch (retryErr) {
+        err = retryErr;
+      }
+    }
+
+    if (NETWORK_RETRY_CODES.has(err?.code)) {
+      const deployment = await findRecentActiveDeployment(appId);
+      if (deployment) {
+        console.error(pc.yellow('Connection dropped after deploy was queued; continuing with the active deployment.'));
+        return {
+          success: true,
+          data: { deployment, queue_position: 1 },
+          message: 'CLI deployment queued',
+        };
+      }
+    }
+
+    mapNetworkError(err, {
+      method: 'POST',
+      path,
+      url,
+    });
   }
 }