@solidactions/cli 1.23.0 → 1.24.0

package/dist/utils/api.js

@@ -5,8 +5,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.augmentNotFoundMessage = augmentNotFoundMessage;
 exports.getApiHeaders = getApiHeaders;
+exports.describeProjectEnvironments = describeProjectEnvironments;
+exports.formatValidationError = formatValidationError;
 exports.requireResolvedConfig = requireResolvedConfig;
 exports.requireConfig = requireConfig;
+exports.authFailureMessage = authFailureMessage;
 exports.ensureWorkspaceSelected = ensureWorkspaceSelected;
 exports.requireConfigWithWorkspace = requireConfigWithWorkspace;
 const axios_1 = __importDefault(require("axios"));
@@ -46,6 +49,59 @@ function getApiHeaders(config, contentType) {
         headers['X-Workspace-Id'] = config.workspaceId;
     return headers;
 }
+/**
+ * Best-effort lookup of the environments a project family actually has
+ * (e.g. "production, dev"), for a friendlier 404 message. Returns null on
+ * any failure — callers should treat that as "no extra detail available."
+ */
+async function describeProjectEnvironments(config, projectName) {
+    try {
+        const res = await axios_1.default.get(`${config.host}/api/v1/projects`, { headers: getApiHeaders(config) });
+        const rows = res.data?.data ?? res.data ?? [];
+        const hit = rows.find((p) => p.name === projectName || p.slug === projectName);
+        const envs = hit?.environments;
+        return envs?.length ? envs.join(', ') : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Render a Laravel-style 422 validation error body as plain readable text —
+ * never a raw JSON dump. Prefers `data.errors` (flattened, one message per
+ * line, with the internal `variables.N.` index prefix stripped and the bare
+ * `key` attribute renamed to `variable key` for clarity); falls back to
+ * `data.message`.
+ */
+function formatValidationError(data) {
+    const errors = data?.errors;
+    let messages = [];
+    if (errors && typeof errors === 'object' && !Array.isArray(errors)) {
+        for (const value of Object.values(errors)) {
+            if (Array.isArray(value)) {
+                messages.push(...value.map((v) => String(v)));
+            }
+            else if (value) {
+                messages.push(String(value));
+            }
+        }
+    }
+    if (messages.length === 0) {
+        const message = data?.message;
+        if (typeof message === 'string' && message) {
+            messages = [message];
+        }
+    }
+    if (messages.length === 0) {
+        return 'Validation failed.';
+    }
+    return messages
+        .map((msg) => msg
+        .replace(/variables\.\d+\.key/gi, 'variable key')
+        .replace(/variable key field/gi, 'variable key')
+        .replace(/variables\.\d+\.(\w+)/gi, '$1'))
+        .join('\n');
+}
 /**
  * Get the full resolution (config + sources + activePath). Exits if nothing resolvable.
  */
@@ -60,6 +116,15 @@ function requireResolvedConfig() {
 function requireConfig() {
     return requireResolvedConfig().config;
 }
+/**
+ * Contextual 401 message — names the host being called and where the (now
+ * apparently invalid/expired) API key came from, instead of a bare
+ * "Authentication failed" that gives no clue which config is at fault.
+ */
+function authFailureMessage(config, sources) {
+    const keySource = sources?.apiKey ?? 'config';
+    return `Authentication failed against ${config.host} (key from ${keySource}). Run \`solidactions login <api-key>\` to re-configure.`;
+}
 async function ensureWorkspaceSelected(config) {
     if (config.workspaceId) {
         return config;
@@ -95,7 +160,7 @@ async function ensureWorkspaceSelected(config) {
     }
     catch (error) {
         if (error.response?.status === 401) {
-            console.error(chalk_1.default.red('Authentication failed. Run `solidactions login <api-key>` to reconfigure.'));
+            console.error(chalk_1.default.red(authFailureMessage(config, resolved?.sources ?? null)));
         }
         else {
             console.error(chalk_1.default.red('Failed to fetch workspaces:'), error.response?.data?.message || error.message);
@@ -148,5 +213,9 @@ async function requireConfigWithWorkspace() {
         config = { ...config, workspace: ws.slug ?? ws.name, workspaceId: ws.id };
         return config;
     }
+    if (!config.workspaceId && !process.stdin.isTTY) {
+        console.error(chalk_1.default.red('No workspace set for this config. Run `solidactions workspace set <name-or-id> --local` (or --global).'));
+        process.exit(1);
+    }
     return ensureWorkspaceSelected(config);
 }

package/dist/utils/config-write-target.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.decideWriteTarget = decideWriteTarget;
 exports.pathForTarget = pathForTarget;
+exports.confirmOverwrite = confirmOverwrite;
 exports.ensureGitignoreCovers = ensureGitignoreCovers;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
@@ -19,7 +20,7 @@ const config_1 = require("./config");
  *  - Else if TTY, prompt.
  *  - Else error and exit.
  */
-async function decideWriteTarget(options, promptLabel = 'Save config locally (./.solidactions) or globally (~/.solidactions)? [global] ') {
+async function decideWriteTarget(options, promptLabel = 'Save config locally (./.solidactions) or globally (~/.solidactions)? [global] ', refusalMessage = 'Refusing to write config non-interactively. Pass --local or --global.') {
     if (options.local && options.global) {
         console.error(chalk_1.default.red('Error: --local and --global are mutually exclusive.'));
         process.exit(1);
@@ -45,17 +46,55 @@ async function decideWriteTarget(options, promptLabel = 'Save config locally (./
             rl.close();
         }
     }
-    console.error(chalk_1.default.red('Refusing to write config non-interactively. Pass --local or --global.'));
+    console.error(chalk_1.default.red(refusalMessage));
     process.exit(1);
 }
 function pathForTarget(target) {
     return target === 'local' ? (0, config_1.getLocalConfigPath)() : (0, config_1.getGlobalConfigPath)();
 }
+/**
+ * Notify (and, on a TTY, confirm) that an existing config file is about to be
+ * overwritten. A backup will be written to `backupPath` regardless of mode —
+ * this always says so. Non-interactive callers (CI, agents) proceed
+ * automatically so they never wedge; an interactive TTY additionally asks a
+ * y/N confirm (default N).
+ */
+async function confirmOverwrite(existingPath, backupPath) {
+    const notice = `Existing config at ${existingPath} will be overwritten (backup will be saved to ${backupPath}).`;
+    if (!process.stdin.isTTY) {
+        console.log(chalk_1.default.yellow(notice));
+        return true;
+    }
+    const rl = readline_1.default.createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = await new Promise((resolve) => rl.question(chalk_1.default.yellow(`${notice} Continue? [y/N] `), resolve));
+        return answer.trim().toLowerCase().startsWith('y');
+    }
+    finally {
+        rl.close();
+    }
+}
 /**
  * Ensure `.solidactions/` is in the target directory's `.gitignore`.
  * Idempotent. Skips silently if pattern is already covered.
  */
+/** Walk up from startDir looking for a `.git` directory. Stops at filesystem root. */
+function findGitRoot(startDir) {
+    let dir = path_1.default.resolve(startDir);
+    while (true) {
+        if (fs_1.default.existsSync(path_1.default.join(dir, '.git'))) {
+            return dir;
+        }
+        const parent = path_1.default.dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
 async function ensureGitignoreCovers(targetDir, auto) {
+    // Not in a git repo — a .gitignore entry protects nothing here; skip silently.
+    if (!findGitRoot(targetDir))
+        return;
     const gitignorePath = path_1.default.join(targetDir, '.gitignore');
     const patternToAdd = '.solidactions/';
     let existing = '';

package/dist/utils/config.js

@@ -151,8 +151,23 @@ function mergeConfigs(env, local, localPath, global, globalPath) {
     };
     const host = pick('host');
     const apiKey = pick('apiKey');
-    const workspace = pick('workspace');
-    const workspaceId = pick('workspaceId');
+    // A local config that defines its own credentials (host or apiKey) is
+    // anchored to a different account/tenant than the global config — its
+    // workspace/workspaceId must never fall back to global (F-C3).
+    // Pure workspace-pin local files (no host/apiKey of their own) keep
+    // inheriting global credentials and so may still inherit the workspace.
+    const localDefinesCreds = !!(local && (local.host !== undefined || local.apiKey !== undefined));
+    const pickWorkspaceField = (key) => {
+        if (env[key] !== undefined)
+            return { value: env[key], source: 'env' };
+        if (local && local[key] !== undefined)
+            return { value: local[key], source: localPath };
+        if (!localDefinesCreds && global && global[key] !== undefined)
+            return { value: global[key], source: globalPath };
+        return { value: undefined, source: null };
+    };
+    const workspace = pickWorkspaceField('workspace');
+    const workspaceId = pickWorkspaceField('workspaceId');
     if (!host.value && !apiKey.value) {
         return null;
     }

package/dist/utils/env.js

@@ -10,6 +10,8 @@ exports.getYamlDeclaredVars = getYamlDeclaredVars;
 exports.loadSolidActionsConfig = loadSolidActionsConfig;
 exports.isReservedEnvName = isReservedEnvName;
 exports.reservedEnvNameError = reservedEnvNameError;
+exports.isValidEnvName = isValidEnvName;
+exports.envNameError = envNameError;
 const fs_1 = __importDefault(require("fs"));
 const js_yaml_1 = __importDefault(require("js-yaml"));
 /**
@@ -81,7 +83,7 @@ function parseYamlEnvVars(config) {
 }
 /**
  * Extract declared variable keys from solidactions.yaml env config.
- * Returns a set of env var keys that are declared in YAML.
+ * Returns a set of variable keys that are declared in YAML.
  */
 function getYamlDeclaredVars(config) {
     const parsedVars = parseYamlEnvVars(config);
@@ -103,10 +105,20 @@ function loadSolidActionsConfig(yamlPath) {
  * matching the server-side rule (App\Support\ReservedEnvNames).
  */
 exports.RESERVED_ENV_PREFIX = 'SOLIDACTIONS_';
+/** Case-insensitive: the server rejects any casing of the prefix, not just uppercase. */
 function isReservedEnvName(key) {
-    return key.startsWith(exports.RESERVED_ENV_PREFIX);
+    return key.toUpperCase().startsWith(exports.RESERVED_ENV_PREFIX);
 }
 function reservedEnvNameError(key) {
-    const suggestion = key.replace(/^SOLIDACTIONS_/, 'MY_');
+    const suggestion = key.replace(/^SOLIDACTIONS_/i, 'MY_');
     return `"${key}" uses the reserved ${exports.RESERVED_ENV_PREFIX} prefix. These names are set by the platform at runtime (API credentials, run context) and a custom variable would clobber them, causing authentication failures. Choose a different name (e.g. "${suggestion}").`;
 }
+/** Env/variable key naming rule: letters, digits, underscore; no leading digit. */
+function isValidEnvName(key) {
+    return /^[A-Za-z_][A-Za-z0-9_]*$/.test(key);
+}
+function envNameError(key) {
+    if (key.trim() === '')
+        return 'Variable key is required.';
+    return `Invalid variable name "${key}" — names must match [A-Za-z_][A-Za-z0-9_]* (letters, digits, underscore; no leading digit).`;
+}

package/dist/utils/mcp.js

@@ -46,6 +46,9 @@ const http = __importStar(require("http"));
 const https = __importStar(require("https"));
 const url_1 = require("url");
 const api_1 = require("./api");
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const pkg = require('../../package.json');
+const CLI_VERSION = pkg.version;
 /**
  * Internal: call a single MCP tool on the given endpoint path.
  *
@@ -85,7 +88,10 @@ async function callMcpTool(config, endpointPath, toolName, args) {
             let raw = '';
             res.on('data', (chunk) => { raw += chunk; });
             res.on('end', () => {
-                if (res.statusCode && res.statusCode >= 400) {
+                if (res.statusCode === 404) {
+                    reject(new Error(`MCP request failed: ${parsed.host} has no ${endpointPath} endpoint — the server may be older or newer than this CLI (${CLI_VERSION}). Raw: HTTP 404 ${raw}`));
+                }
+                else if (res.statusCode && res.statusCode >= 400) {
                     reject(new Error(`MCP request failed with HTTP ${res.statusCode}: ${raw}`));
                 }
                 else {
@@ -116,15 +122,19 @@ async function callMcpTool(config, endpointPath, toolName, args) {
     }
     return { ok: !isError, data: toolData };
 }
+const UNIFIED_MCP_PATH = '/mcp';
+// Server consolidated per-domain MCP servers into one endpoint with namespaced tools.
+const CREWS_TOOL_NAMES = { skills: 'crews_skills', roles: 'crews_roles' };
 /**
- * Call a single MCP tool on /mcp/crews.
+ * Call a single MCP tool on the unified /mcp endpoint, mapping legacy crews
+ * tool names ('skills'/'roles') to their namespaced equivalents.
  */
 async function callCrewsTool(config, toolName, args) {
-    return callMcpTool(config, '/mcp/crews', toolName, args);
+    return callMcpTool(config, UNIFIED_MCP_PATH, CREWS_TOOL_NAMES[toolName] ?? toolName, args);
 }
 /**
- * Call a single MCP tool on /mcp/docs.
+ * Call a single MCP tool on the unified /mcp endpoint.
  */
 async function callDocsTool(config, toolName, args) {
-    return callMcpTool(config, '/mcp/docs', toolName, args);
+    return callMcpTool(config, UNIFIED_MCP_PATH, toolName, args);
 }

package/dist/utils/table.js

@@ -0,0 +1,62 @@
+"use strict";
+// src/utils/table.ts
+//
+// Shared plain-text table renderer (extracted from webhook-formatters.ts's
+// columnWidth helper) used by project-list, env-list, and run-list.
+//
+// Operates on PLAIN (uncolored) cell values only — chalk ANSI escape codes
+// count toward a JS string's .length, so colorizing a cell before padding
+// would corrupt the alignment math. Callers that want color should apply it
+// to the whole rendered line (e.g. chalk.gray(lines[i])), not to individual
+// cell values passed in here.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeCell = sanitizeCell;
+exports.truncateCell = truncateCell;
+exports.computeColumnWidths = computeColumnWidths;
+exports.renderTable = renderTable;
+const DEFAULT_MAX_WIDTH = 60;
+/** Escape embedded newlines so a row can never span multiple terminal lines. */
+function sanitizeCell(value) {
+    return value.replace(/\r?\n/g, '\\n');
+}
+function truncateCell(value, maxWidth = DEFAULT_MAX_WIDTH) {
+    if (value.length <= maxWidth)
+        return value;
+    return value.slice(0, Math.max(0, maxWidth - 1)) + '…';
+}
+/**
+ * Compute per-column widths (`max(minWidth, longest sanitized+truncated cell) + 2`)
+ * without rendering — for callers (e.g. run-list) that need to colorize a
+ * cell's text with chalk AFTER padding (coloring first would corrupt the
+ * alignment math, since ANSI escape codes count toward a JS string's .length).
+ */
+function computeColumnWidths(headers, rows, opts = {}) {
+    const maxWidth = opts.maxWidth ?? DEFAULT_MAX_WIDTH;
+    const minWidths = opts.minWidths ?? [];
+    const clean = (v) => truncateCell(sanitizeCell(v), maxWidth);
+    return headers.map((h, i) => {
+        const longest = Math.max(clean(h).length, ...rows.map((r) => clean(r[i] ?? '').length));
+        return Math.max(minWidths[i] ?? 0, longest) + 2;
+    });
+}
+/**
+ * Render a simple aligned table as an array of lines: `[header, divider, ...rows]`.
+ * Column widths are dynamic — `max(minWidth, longest cell in that column) + 2`.
+ */
+function renderTable(headers, rows, opts = {}) {
+    const maxWidth = opts.maxWidth ?? DEFAULT_MAX_WIDTH;
+    const minWidths = opts.minWidths ?? [];
+    const cleanHeaders = headers.map((h) => truncateCell(sanitizeCell(h), maxWidth));
+    const cleanRows = rows.map((row) => row.map((cell) => truncateCell(sanitizeCell(cell), maxWidth)));
+    const widths = cleanHeaders.map((h, i) => {
+        const longest = Math.max(h.length, ...cleanRows.map((r) => r[i]?.length ?? 0));
+        return Math.max(minWidths[i] ?? 0, longest) + 2;
+    });
+    const renderRow = (cells) => cells.map((cell, i) => (i === cells.length - 1 ? cell : (cell ?? '').padEnd(widths[i]))).join('');
+    const totalWidth = widths.reduce((a, b) => a + b, 0);
+    return [
+        renderRow(cleanHeaders),
+        '-'.repeat(totalWidth),
+        ...cleanRows.map(renderRow),
+    ];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidactions/cli",
-  "version": "1.23.0",
+  "version": "1.24.0",
   "description": "SolidActions CLI - Deploy and manage workflow automation",
   "main": "dist/index.js",
   "bin": {