@solidactions/cli 0.1.0

package/README.md

@@ -0,0 +1,56 @@
+# SolidActions CLI
+
+Deploy and manage workflow automation with SolidActions.
+
+## Installation
+
+```bash
+npm install -g @solidactions/cli
+```
+
+## Quick Start
+
+```bash
+# Initialize with your API key
+solidactions init <api-key>
+
+# Deploy a project
+solidactions deploy <project-name> <path>
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `init <api-key>` | Initialize CLI with your API key |
+| `logout` | Remove saved credentials |
+| `whoami` | Show current configuration |
+| `deploy <project> [path]` | Deploy a project to SolidActions |
+| `pull <project> [path]` | Pull project source from SolidActions |
+| `run <project> <workflow>` | Trigger a workflow run |
+| `runs [project]` | List recent workflow runs |
+| `logs <run-id>` | View logs for a workflow run |
+| `logs:build <project>` | View build/deployment logs |
+| `env:create <key> <value>` | Create a global environment variable |
+| `env:list [project]` | List environment variables |
+| `env:delete <key>` | Delete an environment variable |
+| `env:map <project> <key> <global-key>` | Map a global variable to a project |
+| `env:pull <project>` | Pull resolved env vars to a local file |
+| `schedule:set <project> <cron>` | Set a cron schedule for a workflow |
+| `schedule:list <project>` | List schedules for a project |
+| `schedule:delete <project> <id>` | Delete a schedule |
+
+See [docs/cli.md](docs/cli.md) for full documentation.
+
+## Development
+
+```bash
+git clone https://github.com/SolidActions/solidactions-cli.git
+cd solidactions-cli
+npm install
+npm run build
+```
+
+## License
+
+MIT

package/dist/commands/deploy.js

@@ -0,0 +1,454 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deploy = deploy;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const archiver_1 = __importDefault(require("archiver"));
+const axios_1 = __importDefault(require("axios"));
+const form_data_1 = __importDefault(require("form-data"));
+const chalk_1 = __importDefault(require("chalk"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const init_1 = require("./init");
+/**
+ * Validate project structure before deployment.
+ * Checks for required files and SDK dependency.
+ */
+function validateProject(sourceDir) {
+    const errors = [];
+    const warnings = [];
+    // Check for solidactions.yaml
+    const solidactionsPath = path_1.default.join(sourceDir, 'solidactions.yaml');
+    if (!fs_1.default.existsSync(solidactionsPath)) {
+        errors.push('solidactions.yaml not found. This file defines your workflows.');
+        return { valid: false, errors, warnings };
+    }
+    // Check for package.json
+    const packageJsonPath = path_1.default.join(sourceDir, 'package.json');
+    if (!fs_1.default.existsSync(packageJsonPath)) {
+        errors.push('package.json not found. Initialize with: npm init');
+        return { valid: false, errors, warnings };
+    }
+    // Read and validate package.json
+    const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf8'));
+    const allDeps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+    // Check for SDK - either @solidactions/sdk or bundled sdk folder
+    const hasSdkPackage = '@solidactions/sdk' in allDeps;
+    const hasBundledSdk = fs_1.default.existsSync(path_1.default.join(sourceDir, 'sdk'));
+    if (!hasSdkPackage && !hasBundledSdk) {
+        errors.push('Missing SDK in package.json dependencies. Run: npm install @solidactions/sdk');
+    }
+    // Check for TypeScript config if .ts files are used
+    const srcDir = path_1.default.join(sourceDir, 'src');
+    const hasTypeScriptFiles = fs_1.default.existsSync(srcDir) &&
+        fs_1.default.readdirSync(srcDir).some(f => f.endsWith('.ts') || f.endsWith('.tsx'));
+    if (hasTypeScriptFiles) {
+        const tsconfigPath = path_1.default.join(sourceDir, 'tsconfig.json');
+        if (!fs_1.default.existsSync(tsconfigPath)) {
+            warnings.push('TypeScript files detected but tsconfig.json not found. Build may fail.');
+        }
+    }
+    // Parse and validate solidactions.yaml
+    try {
+        const configContent = fs_1.default.readFileSync(solidactionsPath, 'utf8');
+        const config = js_yaml_1.default.load(configContent);
+        if (!config || !config.workflows || !Array.isArray(config.workflows)) {
+            errors.push('Invalid solidactions.yaml: workflows section is required.');
+        }
+        else {
+            // Validate each workflow
+            for (const wf of config.workflows) {
+                if (!wf.name) {
+                    errors.push(`Workflow missing required 'name' field.`);
+                    continue;
+                }
+                // Must have either command: or file:
+                if (!wf.command && !wf.file) {
+                    errors.push(`Workflow "${wf.name}": must specify either 'command:' or 'file:'.`);
+                    continue;
+                }
+                // If file: is specified, verify the file exists
+                if (wf.file) {
+                    const filePath = path_1.default.join(sourceDir, wf.file);
+                    if (!fs_1.default.existsSync(filePath)) {
+                        errors.push(`Workflow "${wf.name}": file "${wf.file}" not found.`);
+                    }
+                }
+            }
+        }
+    }
+    catch (err) {
+        errors.push(`Failed to parse solidactions.yaml: ${err.message}`);
+    }
+    return { valid: errors.length === 0, errors, warnings };
+}
+/**
+ * Parse a .env file into a key-value map.
+ */
+function parseEnvFile(filePath) {
+    const envMap = new Map();
+    if (!fs_1.default.existsSync(filePath)) {
+        return envMap;
+    }
+    const content = fs_1.default.readFileSync(filePath, 'utf8');
+    const lines = content.split('\n');
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Skip empty lines and comments
+        if (!trimmed || trimmed.startsWith('#')) {
+            continue;
+        }
+        const equalsIndex = trimmed.indexOf('=');
+        if (equalsIndex === -1) {
+            continue;
+        }
+        const key = trimmed.substring(0, equalsIndex).trim();
+        let value = trimmed.substring(equalsIndex + 1).trim();
+        // Remove surrounding quotes if present
+        if ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        envMap.set(key, value);
+    }
+    return envMap;
+}
+/**
+ * Parse YAML env declarations into structured format.
+ * Handles the new simplified format:
+ *   - VAR_NAME           -> { key: "VAR_NAME", mappedTo: null }
+ *   - VAR_NAME: GLOBAL   -> { key: "VAR_NAME", mappedTo: "GLOBAL" }
+ */
+function parseYamlEnvVars(config) {
+    const parsedVars = [];
+    if (!config.env || !Array.isArray(config.env)) {
+        return parsedVars;
+    }
+    for (const item of config.env) {
+        if (typeof item === 'string') {
+            // Simple string: - VAR_NAME (declared only, needs configuration)
+            parsedVars.push({ key: item, mappedTo: null });
+        }
+        else if (typeof item === 'object' && item !== null) {
+            // Object: - VAR_NAME: GLOBAL_NAME (mapped to global)
+            const keys = Object.keys(item);
+            if (keys.length === 1) {
+                const key = keys[0];
+                const mappedTo = item[key];
+                parsedVars.push({ key, mappedTo: mappedTo || null });
+            }
+        }
+    }
+    return parsedVars;
+}
+/**
+ * Extract declared variable keys from solidactions.yaml env config.
+ * Returns a set of env var keys that are declared in YAML.
+ */
+function getYamlDeclaredVars(config) {
+    const parsedVars = parseYamlEnvVars(config);
+    return new Set(parsedVars.map(v => v.key));
+}
+/**
+ * Check if deployEnv is enabled in the config.
+ * New format has deployEnv at top level.
+ */
+function isDeployEnvEnabled(config) {
+    return config.deployEnv === true;
+}
+/**
+ * Push YAML env declarations to the project.
+ * This registers all YAML-declared vars and their mappings.
+ */
+async function pushYamlDeclarations(host, apiKey, projectSlug, yamlConfig) {
+    const parsedVars = parseYamlEnvVars(yamlConfig);
+    if (parsedVars.length === 0) {
+        return;
+    }
+    // Build the declarations array
+    const declarations = parsedVars.map(v => ({
+        env_name: v.key,
+        yaml_default_global_key: v.mappedTo,
+        source: 'yaml',
+    }));
+    try {
+        await axios_1.default.post(`${host}/api/v1/projects/${projectSlug}/variable-mappings/sync-yaml`, { declarations }, {
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Accept': 'application/json',
+                'Content-Type': 'application/json',
+            },
+        });
+        console.log(chalk_1.default.gray(`Synced ${declarations.length} YAML env declarations`));
+    }
+    catch (error) {
+        console.error(chalk_1.default.yellow('Warning: Failed to sync YAML declarations:'), error.response?.data?.message || error.message);
+    }
+}
+/**
+ * Push environment variables from .env file to project.
+ * Only pushes vars that are declared in solidactions.yaml.
+ */
+async function pushEnvVars(host, apiKey, projectSlug, sourceDir, environment, yamlConfig) {
+    // Get vars declared in YAML
+    const declaredVars = getYamlDeclaredVars(yamlConfig);
+    if (declaredVars.size === 0) {
+        console.log(chalk_1.default.gray('No environment variables declared in solidactions.yaml'));
+        return;
+    }
+    // Read the .env file for this environment
+    const envFileName = environment === 'production' ? '.env' : `.env.${environment}`;
+    const envFilePath = path_1.default.join(sourceDir, envFileName);
+    if (!fs_1.default.existsSync(envFilePath)) {
+        console.log(chalk_1.default.yellow(`⚠ ${envFileName} not found, skipping env push`));
+        // Warn about each missing declared var
+        for (const key of declaredVars) {
+            console.log(chalk_1.default.yellow(`  ⚠ ${key}: no value (not in ${envFileName})`));
+        }
+        return;
+    }
+    // Parse the .env file
+    const envValues = parseEnvFile(envFilePath);
+    // Filter to only YAML-declared vars
+    const variables = [];
+    const missing = [];
+    for (const key of declaredVars) {
+        const value = envValues.get(key);
+        if (value !== undefined) {
+            // Mark vars containing "secret", "key", "token", "password" as secrets
+            const isSecret = /secret|key|token|password|credential/i.test(key);
+            variables.push({ key, value, is_secret: isSecret });
+        }
+        else {
+            missing.push(key);
+        }
+    }
+    // Warn about missing vars
+    for (const key of missing) {
+        console.log(chalk_1.default.yellow(`⚠ ${key}: not found in ${envFileName}`));
+    }
+    if (variables.length === 0) {
+        console.log(chalk_1.default.yellow('No matching environment variables to push'));
+        return;
+    }
+    // Push to API
+    try {
+        const response = await axios_1.default.post(`${host}/api/v1/projects/${projectSlug}/variable-mappings/bulk`, { variables }, {
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Accept': 'application/json',
+                'Content-Type': 'application/json',
+            },
+        });
+        const { created, updated } = response.data;
+        console.log(chalk_1.default.green(`✓ Pushed ${variables.length} environment variables from ${envFileName}`));
+        if (created > 0 || updated > 0) {
+            console.log(chalk_1.default.gray(`  (${created} created, ${updated} updated)`));
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('Failed to push environment variables:'), error.response?.data?.message || error.message);
+    }
+}
+async function deploy(projectName, sourcePath, options = {}) {
+    const config = (0, init_1.getConfig)();
+    if (!config?.apiKey) {
+        console.error(chalk_1.default.red('Not initialized. Run `solidactions init <api-key>` first.'));
+        process.exit(1);
+    }
+    const sourceDir = sourcePath ? path_1.default.resolve(sourcePath) : process.cwd();
+    const environment = options.env || 'production';
+    if (!fs_1.default.existsSync(sourceDir)) {
+        console.error(chalk_1.default.red(`Source directory not found: ${sourceDir}`));
+        process.exit(1);
+    }
+    const envLabel = environment !== 'production' ? ` (${environment})` : '';
+    console.log(chalk_1.default.blue(`Deploying to project "${projectName}"${envLabel}...`));
+    console.log(chalk_1.default.gray(`Source: ${sourceDir}`));
+    // Validate project structure before deploying
+    console.log(chalk_1.default.gray('Validating project structure...'));
+    const validation = validateProject(sourceDir);
+    // Parse solidactions.yaml for env config
+    const solidactionsPath = path_1.default.join(sourceDir, 'solidactions.yaml');
+    let yamlConfig = null;
+    try {
+        const configContent = fs_1.default.readFileSync(solidactionsPath, 'utf8');
+        yamlConfig = js_yaml_1.default.load(configContent);
+    }
+    catch {
+        // Config parsing errors are handled by validateProject
+    }
+    if (validation.warnings.length > 0) {
+        for (const warning of validation.warnings) {
+            console.log(chalk_1.default.yellow(`⚠ ${warning}`));
+        }
+    }
+    if (!validation.valid) {
+        console.error(chalk_1.default.red('\nDeployment failed - validation errors:\n'));
+        for (const error of validation.errors) {
+            console.error(chalk_1.default.red(`  ✗ ${error}`));
+        }
+        console.error('');
+        process.exit(1);
+    }
+    console.log(chalk_1.default.green('✓ Project structure validated'));
+    // Check if project exists, create if not
+    let projectSlug = projectName;
+    try {
+        // For non-production environments, append the environment to the slug for lookup
+        const lookupSlug = environment === 'production'
+            ? projectName
+            : `${projectName}-${environment}`;
+        const checkResponse = await axios_1.default.get(`${config.host}/api/v1/projects/${lookupSlug}`, {
+            headers: {
+                'Authorization': `Bearer ${config.apiKey}`,
+                'Accept': 'application/json',
+            },
+        });
+        projectSlug = checkResponse.data.slug || checkResponse.data.name;
+    }
+    catch (error) {
+        if (error.response?.status === 404) {
+            // For non-production environments, check if we should create
+            if (environment !== 'production' && !options.create) {
+                console.log(chalk_1.default.yellow(`Project "${projectName}" doesn't have a ${environment} environment.`));
+                console.log(chalk_1.default.gray('Use --create to create it, or deploy to production first.'));
+                process.exit(1);
+            }
+            console.log(chalk_1.default.yellow(`Project "${projectName}"${envLabel} not found. Creating...`));
+            try {
+                const createResponse = await axios_1.default.post(`${config.host}/api/v1/projects`, {
+                    name: projectName,
+                    slug: projectName.toLowerCase().replace(/[^a-z0-9-]/g, '-') + (environment !== 'production' ? `-${environment}` : ''),
+                    environment: environment,
+                }, {
+                    headers: {
+                        'Authorization': `Bearer ${config.apiKey}`,
+                        'Accept': 'application/json',
+                        'Content-Type': 'application/json',
+                    },
+                });
+                projectSlug = createResponse.data.slug || createResponse.data.name;
+                console.log(chalk_1.default.green(`Project "${projectName}"${envLabel} created.`));
+            }
+            catch (createError) {
+                console.error(chalk_1.default.red('Failed to create project:'), createError.response?.data?.message || createError.message);
+                process.exit(1);
+            }
+        }
+        else {
+            console.error(chalk_1.default.red('Failed to check project:'), error.response?.data?.message || error.message);
+            process.exit(1);
+        }
+    }
+    const zipPath = path_1.default.join(sourceDir, '.steps-deploy.zip');
+    const output = fs_1.default.createWriteStream(zipPath);
+    const archive = (0, archiver_1.default)('zip', { zlib: { level: 9 } });
+    output.on('close', async () => {
+        console.log(chalk_1.default.gray(`Zipped ${archive.pointer()} total bytes`));
+        try {
+            const form = new form_data_1.default();
+            form.append('source', fs_1.default.createReadStream(zipPath));
+            console.log(chalk_1.default.yellow('Uploading...'));
+            await axios_1.default.post(`${config.host}/api/v1/projects/${projectSlug}/deploy`, form, {
+                headers: {
+                    ...form.getHeaders(),
+                    'Accept': 'application/json',
+                    'Authorization': `Bearer ${config.apiKey}`,
+                },
+                maxContentLength: Infinity,
+                maxBodyLength: Infinity
+            });
+            console.log(chalk_1.default.green('Deployment successfully queued!'));
+            console.log(chalk_1.default.yellow('Waiting for build to complete...\n'));
+            // Poll for completion
+            let attempts = 0;
+            const maxAttempts = 120; // 2 minutes timeout
+            let lastLogLength = 0;
+            const poll = setInterval(async () => {
+                try {
+                    attempts++;
+                    const statusRes = await axios_1.default.get(`${config.host}/api/v1/projects/${projectSlug}`, {
+                        headers: { 'Authorization': `Bearer ${config.apiKey}` }
+                    });
+                    const { status, build_log } = statusRes.data;
+                    // Stream new log content
+                    if (build_log && build_log.length > lastLogLength) {
+                        const newContent = build_log.substring(lastLogLength);
+                        process.stdout.write(chalk_1.default.gray(newContent));
+                        if (!newContent.endsWith('\n')) {
+                            process.stdout.write('\n');
+                        }
+                        lastLogLength = build_log.length;
+                    }
+                    if (status === 'deployed') {
+                        clearInterval(poll);
+                        console.log(chalk_1.default.green(`\n✓ Deployed to ${projectSlug}${envLabel}!`));
+                        // Always sync YAML declarations (registers env vars and their mappings)
+                        if (yamlConfig) {
+                            await pushYamlDeclarations(config.host, config.apiKey, projectSlug, yamlConfig);
+                        }
+                        // Push .env values if deployEnv is enabled
+                        if (yamlConfig && isDeployEnvEnabled(yamlConfig)) {
+                            console.log(chalk_1.default.blue('\nPushing environment variables...'));
+                            await pushEnvVars(config.host, config.apiKey, projectSlug, sourceDir, environment, yamlConfig);
+                        }
+                        fs_1.default.unlinkSync(zipPath);
+                        process.exit(0);
+                    }
+                    else if (status === 'error') {
+                        clearInterval(poll);
+                        console.error(chalk_1.default.red('\n✗ Build Failed!'));
+                        if (build_log) {
+                            console.log(chalk_1.default.yellow('\n--- Full Build Log ---'));
+                            console.log(chalk_1.default.gray(build_log));
+                            console.log(chalk_1.default.yellow('--- End Build Log ---\n'));
+                        }
+                        fs_1.default.unlinkSync(zipPath);
+                        process.exit(1);
+                    }
+                    else if (attempts >= maxAttempts) {
+                        clearInterval(poll);
+                        console.error(chalk_1.default.red('\nTimeout waiting for build. It might still finish.'));
+                        fs_1.default.unlinkSync(zipPath);
+                        process.exit(1);
+                    }
+                }
+                catch {
+                    // Ignore transient errors
+                }
+            }, 1000);
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('Deployment failed:'));
+            if (error.response) {
+                if (error.response.status === 404) {
+                    console.error("Project not found.");
+                }
+                else {
+                    console.error(error.response.status, JSON.stringify(error.response.data, null, 2));
+                }
+            }
+            else {
+                console.error(error.message);
+            }
+            if (fs_1.default.existsSync(zipPath))
+                fs_1.default.unlinkSync(zipPath);
+            process.exit(1);
+        }
+    });
+    archive.on('error', (err) => {
+        throw err;
+    });
+    archive.pipe(output);
+    // Glob patterns to ignore
+    const ignore = ['node_modules/**', '.git/**', '.steps-deploy.zip', 'dist/**', 'vendor/**', '**/node_modules/**'];
+    archive.glob('**/*', {
+        cwd: sourceDir,
+        ignore: ignore,
+        dot: true
+    });
+    await archive.finalize();
+}

package/dist/commands/env-create.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.envCreate = envCreate;
+const axios_1 = __importDefault(require("axios"));
+const chalk_1 = __importDefault(require("chalk"));
+const init_1 = require("./init");
+async function envCreate(key, value, options = {}) {
+    const config = (0, init_1.getConfig)();
+    if (!config?.apiKey) {
+        console.error(chalk_1.default.red('Not initialized. Run "solidactions init <api-key>" first.'));
+        process.exit(1);
+    }
+    console.log(chalk_1.default.blue(`Creating global variable "${key}"...`));
+    // Build the request body with per-environment values
+    const body = {
+        key,
+        production_value: value,
+        is_secret: options.secret || false,
+    };
+    // Handle staging value and inheritance
+    if (options.stagingInherit) {
+        body.staging_source = 'inherit_production';
+    }
+    else if (options.stagingValue !== undefined) {
+        body.staging_value = options.stagingValue;
+        body.staging_source = 'value';
+    }
+    // Handle dev value and inheritance
+    if (options.devInheritStaging) {
+        body.dev_source = 'inherit_staging';
+    }
+    else if (options.devInherit) {
+        body.dev_source = 'inherit_production';
+    }
+    else if (options.devValue !== undefined) {
+        body.dev_value = options.devValue;
+        body.dev_source = 'value';
+    }
+    try {
+        await axios_1.default.post(`${config.host}/api/v1/variables`, body, {
+            headers: {
+                'Authorization': `Bearer ${config.apiKey}`,
+                'Accept': 'application/json',
+                'Content-Type': 'application/json',
+            },
+        });
+        const typeLabel = options.secret ? 'secret' : 'variable';
+        console.log(chalk_1.default.green(`Global ${typeLabel} "${key}" created successfully!`));
+        // Show summary of what was set
+        console.log(chalk_1.default.gray(`  Production: ${options.secret ? '********' : value}`));
+        if (options.stagingValue) {
+            console.log(chalk_1.default.gray(`  Staging: ${options.secret ? '********' : options.stagingValue}`));
+        }
+        else if (options.stagingInherit) {
+            console.log(chalk_1.default.gray('  Staging: (inherits from production)'));
+        }
+        if (options.devValue) {
+            console.log(chalk_1.default.gray(`  Dev: ${options.secret ? '********' : options.devValue}`));
+        }
+        else if (options.devInheritStaging) {
+            console.log(chalk_1.default.gray('  Dev: (inherits from staging)'));
+        }
+        else if (options.devInherit) {
+            console.log(chalk_1.default.gray('  Dev: (inherits from production)'));
+        }
+    }
+    catch (error) {
+        if (error.response) {
+            if (error.response.status === 401) {
+                console.error(chalk_1.default.red('Authentication failed. Run "solidactions init <api-key>" to re-configure.'));
+            }
+            else if (error.response.status === 422) {
+                console.error(chalk_1.default.red('Validation error:'), error.response.data.message || error.response.data.errors);
+            }
+            else {
+                console.error(chalk_1.default.red(`Failed: ${error.response.status}`), error.response.data);
+            }
+        }
+        else {
+            console.error(chalk_1.default.red('Connection failed:'), error.message);
+        }
+        process.exit(1);
+    }
+}