myaidev-method 0.0.8 → 0.2.0

package/src/scripts/astro-publish.js

@@ -0,0 +1,209 @@
+#!/usr/bin/env node
+
+/**
+ * Astro Publishing Script
+ * Publish markdown content to Astro site
+ */
+
+import { StaticSiteUtils } from '../lib/static-site-utils.js';
+
+const args = process.argv.slice(2);
+
+const options = {
+  file: null,
+  type: 'content',
+  projectPath: null,
+  branch: 'main',
+  noPush: false,
+  commitMessage: null,
+  json: args.includes('--json'),
+  verbose: args.includes('--verbose') || args.includes('-v'),
+  dryRun: args.includes('--dry-run')
+};
+
+// Parse arguments
+for (let i = 0; i < args.length; i++) {
+  switch (args[i]) {
+    case '--file':
+    case '-f':
+      options.file = args[++i];
+      break;
+    case '--type':
+    case '-t':
+      options.type = args[++i];
+      break;
+    case '--project':
+    case '-p':
+      options.projectPath = args[++i];
+      break;
+    case '--branch':
+    case '-b':
+      options.branch = args[++i];
+      break;
+    case '--no-push':
+      options.noPush = true;
+      break;
+    case '--message':
+    case '-m':
+      options.commitMessage = args[++i];
+      break;
+    case '--help':
+    case '-h':
+      printHelp();
+      process.exit(0);
+  }
+}
+
+// If no file specified, check positional argument
+if (!options.file && args.length > 0 && !args[0].startsWith('-')) {
+  options.file = args[0];
+}
+
+function printHelp() {
+  console.log(`
+Astro Publishing Script
+
+Usage: astro-publish [file] [options]
+
+Arguments:
+  file                       Markdown file to publish (required)
+
+Options:
+  --type, -t <type>          Content type: content|pages (default: content)
+  --project, -p <path>       Astro project path
+  --branch, -b <branch>      Git branch to push to (default: main)
+  --no-push                  Commit but don't push to remote
+  --message, -m <msg>        Custom commit message
+  --dry-run                  Validate without committing
+  --verbose, -v              Show detailed progress
+  --json                     Output in JSON format
+  --help, -h                 Show this help
+
+Examples:
+  # Publish to content collection
+  astro-publish article.md
+
+  # Publish to pages
+  astro-publish page.md --type pages
+
+  # Custom project path and branch
+  astro-publish article.md --project ./my-astro-site --branch develop
+
+  # Commit only (no push)
+  astro-publish article.md --no-push
+`);
+}
+
+async function publishContent() {
+  try {
+    // Validate required options
+    if (!options.file) {
+      console.error('Error: Markdown file is required');
+      console.error('Run with --help for usage information');
+      process.exit(1);
+    }
+
+    if (options.verbose) {
+      console.error('Initializing Astro publishing...');
+    }
+
+    const site = new StaticSiteUtils({
+      platform: 'astro',
+      projectPath: options.projectPath
+    });
+
+    if (options.verbose) {
+      console.error('✓ Astro project detected');
+      console.error(`Publishing to: ${options.type}`);
+    }
+
+    // Validate project
+    site.validateProject();
+
+    if (options.verbose) {
+      console.error('✓ Project structure validated');
+    }
+
+    // Dry run - validate only
+    if (options.dryRun) {
+      if (options.verbose) {
+        console.error('✓ Dry run - validation successful');
+      }
+
+      const output = {
+        success: true,
+        dryRun: true,
+        file: options.file,
+        platform: 'astro',
+        type: options.type
+      };
+
+      if (options.json) {
+        console.log(JSON.stringify(output, null, 2));
+      } else {
+        console.log('Dry run successful - ready to publish');
+      }
+
+      process.exit(0);
+    }
+
+    // Publish content
+    const result = await site.publishContent(options.file, {
+      type: options.type,
+      branch: options.branch,
+      noPush: options.noPush,
+      commitMessage: options.commitMessage
+    });
+
+    if (options.verbose) {
+      console.error(`✓ Content published successfully`);
+    }
+
+    // Prepare output
+    const output = {
+      success: true,
+      file: result.file,
+      platform: result.platform,
+      git: result.git,
+      timestamp: new Date().toISOString()
+    };
+
+    if (options.json) {
+      console.log(JSON.stringify(output, null, 2));
+    } else {
+      console.log('\\n' + '='.repeat(60));
+      console.log('Astro Publishing Result');
+      console.log('='.repeat(60));
+      console.log(`Status: ✓ Success`);
+      console.log(`File: ${result.file}`);
+      console.log(`Committed: ${result.git.committed ? 'Yes' : 'No'}`);
+      console.log(`Pushed: ${result.git.pushed ? 'Yes' : 'No'}`);
+      if (result.git.branch) {
+        console.log(`Branch: ${result.git.branch}`);
+      }
+      console.log('='.repeat(60));
+    }
+
+    process.exit(0);
+  } catch (error) {
+    if (options.json) {
+      console.log(JSON.stringify({
+        success: false,
+        error: error.message,
+        timestamp: new Date().toISOString()
+      }, null, 2));
+    } else {
+      console.error(`\\nError: ${error.message}`);
+      if (options.verbose) {
+        console.error(`Stack: ${error.stack}`);
+      }
+    }
+    process.exit(1);
+  }
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  publishContent();
+}
+
+export { publishContent };

package/src/scripts/coolify-deploy-app.js

@@ -0,0 +1,287 @@
+#!/usr/bin/env node
+
+/**
+ * Coolify Application Deployment Script
+ * Deploy applications to Coolify with full configuration support
+ */
+
+import { CoolifyUtils } from '../lib/coolify-utils.js';
+
+const args = process.argv.slice(2);
+
+const options = {
+  name: null,
+  repo: null,
+  branch: 'main',
+  buildPack: 'nixpacks',
+  port: '3000',
+  domain: null,
+  serverUuid: null,
+  projectUuid: null,
+  envFile: null,
+  instant: false,
+  force: false,
+  wait: true,
+  json: args.includes('--json'),
+  verbose: args.includes('--verbose') || args.includes('-v')
+};
+
+// Parse arguments
+for (let i = 0; i < args.length; i++) {
+  switch (args[i]) {
+    case '--name':
+      options.name = args[++i];
+      break;
+    case '--repo':
+    case '--repository':
+      options.repo = args[++i];
+      break;
+    case '--branch':
+      options.branch = args[++i];
+      break;
+    case '--build-pack':
+      options.buildPack = args[++i];
+      break;
+    case '--port':
+      options.port = args[++i];
+      break;
+    case '--domain':
+      options.domain = args[++i];
+      break;
+    case '--server-uuid':
+      options.serverUuid = args[++i];
+      break;
+    case '--project-uuid':
+      options.projectUuid = args[++i];
+      break;
+    case '--env-file':
+      options.envFile = args[++i];
+      break;
+    case '--instant':
+      options.instant = true;
+      break;
+    case '--force':
+      options.force = true;
+      break;
+    case '--no-wait':
+      options.wait = false;
+      break;
+    case '--help':
+    case '-h':
+      printHelp();
+      process.exit(0);
+  }
+}
+
+function printHelp() {
+  console.log(`
+Coolify Application Deployment Script
+
+Usage: coolify-deploy-app [options]
+
+Required Options:
+  --name <name>              Application name
+  --repo <url>               Git repository URL
+  --project-uuid <uuid>      Target project UUID
+  --server-uuid <uuid>       Target server UUID
+
+Optional Options:
+  --branch <name>            Git branch (default: main)
+  --build-pack <type>        Build pack: nixpacks, dockerfile, static (default: nixpacks)
+  --port <port>              Application port (default: 3000)
+  --domain <domain>          Domain name for the application
+  --env-file <path>          Environment variables file
+  --instant                  Deploy instantly (skip queue)
+  --force                    Force rebuild
+  --no-wait                  Don't wait for deployment to complete
+  --verbose                  Show detailed progress
+  -v                         Alias for --verbose
+  --json                     Output in JSON format
+  --help                     Show this help
+  -h                         Alias for --help
+
+Examples:
+  # Basic deployment
+  node src/scripts/coolify-deploy-app.js \\
+    --name "myapp" \\
+    --repo "https://github.com/user/myapp" \\
+    --project-uuid "zg44coscocg0sko8k0wgcgkw" \\
+    --server-uuid "vcscogc44gko4k880ww880kk"
+
+  # With custom domain and environment
+  node src/scripts/coolify-deploy-app.js \\
+    --name "api-prod" \\
+    --repo "https://github.com/user/api" \\
+    --branch "production" \\
+    --domain "api.example.com" \\
+    --env-file ".env.production" \\
+    --project-uuid "zg44coscocg0sko8k0wgcgkw" \\
+    --server-uuid "vcscogc44gko4k880ww880kk"
+
+  # Dockerfile-based deployment
+  node src/scripts/coolify-deploy-app.js \\
+    --name "docker-app" \\
+    --repo "https://github.com/user/docker-app" \\
+    --build-pack "dockerfile" \\
+    --port "8080" \\
+    --project-uuid "zg44coscocg0sko8k0wgcgkw" \\
+    --server-uuid "vcscogc44gko4k880ww880kk"
+`);
+}
+
+async function deployApplication() {
+  try {
+    // Validate required options
+    if (!options.name || !options.repo || !options.projectUuid || !options.serverUuid) {
+      console.error('Error: Missing required options');
+      console.error('Required: --name, --repo, --project-uuid, --server-uuid');
+      console.error('Run with --help for usage information');
+      process.exit(1);
+    }
+
+    if (options.verbose) {
+      console.error('Initializing Coolify connection...');
+    }
+
+    const coolify = new CoolifyUtils();
+
+    // Verify connectivity
+    const healthy = await coolify.healthCheck();
+    if (!healthy) {
+      throw new Error('Coolify is not reachable');
+    }
+
+    if (options.verbose) {
+      console.error('✓ Coolify is reachable');
+      console.error(`Deploying application: ${options.name}`);
+      console.error(`Repository: ${options.repo}`);
+      console.error(`Branch: ${options.branch}`);
+      console.error(`Build pack: ${options.buildPack}`);
+    }
+
+    // Build application configuration (Coolify API format)
+    const appConfig = {
+      project_uuid: options.projectUuid,
+      server_uuid: options.serverUuid,
+      environment_name: 'production', // Required field
+      git_repository: options.repo,
+      git_branch: options.branch,
+      name: options.name,
+      description: `Deployed via myaidev-method on ${new Date().toISOString()}`,
+      build_pack: options.buildPack,
+      ports_exposes: options.port,
+      instant_deploy: options.instant,
+      domains: options.domain ? [options.domain] : []
+    };
+
+    // Load environment variables if specified
+    if (options.envFile) {
+      if (options.verbose) {
+        console.error(`Loading environment from: ${options.envFile}`);
+      }
+      // Environment variables would be loaded here
+      // For now, we'll skip this as it requires reading the file
+    }
+
+    if (options.verbose) {
+      console.error('Creating application in Coolify...');
+    }
+
+    // Create application
+    const app = await coolify.createApplication(appConfig);
+
+    if (options.verbose) {
+      console.error(`✓ Application created: ${app.uuid}`);
+      console.error('Starting deployment...');
+    }
+
+    // Deploy application
+    const deployment = await coolify.deployApplication(app.uuid, {
+      force: options.force,
+      instant: options.instant
+    });
+
+    if (options.verbose) {
+      console.error('✓ Deployment triggered');
+    }
+
+    let result = { success: true, status: 'deployed' };
+
+    // Wait for deployment to complete
+    if (options.wait) {
+      if (options.verbose) {
+        console.error('Waiting for deployment to complete...');
+      }
+
+      result = await coolify.waitForDeployment(app.uuid, {
+        maxAttempts: 120,
+        interval: 5000
+      });
+
+      if (options.verbose) {
+        if (result.success) {
+          console.error(`✓ Deployment completed successfully after ${result.attempts} checks`);
+        } else {
+          console.error(`✗ Deployment failed with status: ${result.status}`);
+        }
+      }
+    }
+
+    // Get final application state
+    const finalApp = await coolify.getApplication(app.uuid);
+
+    // Prepare output
+    const output = {
+      success: result.success,
+      application: {
+        uuid: finalApp.uuid,
+        name: finalApp.name,
+        status: finalApp.status || 'unknown',
+        url: finalApp.fqdn || 'Not configured',
+        repository: options.repo,
+        branch: options.branch
+      },
+      deployment: {
+        status: result.status,
+        timestamp: new Date().toISOString()
+      }
+    };
+
+    if (options.json) {
+      console.log(JSON.stringify(output, null, 2));
+    } else {
+      console.log('\n' + '='.repeat(60));
+      console.log('Deployment Result');
+      console.log('='.repeat(60));
+      console.log(`Status: ${result.success ? '✓ Success' : '✗ Failed'}`);
+      console.log(`Application: ${finalApp.name}`);
+      console.log(`UUID: ${finalApp.uuid}`);
+      console.log(`URL: ${finalApp.fqdn || 'Configure domain in Coolify'}`);
+      console.log(`Repository: ${options.repo}`);
+      console.log(`Branch: ${options.branch}`);
+      console.log('='.repeat(60));
+    }
+
+    process.exit(result.success ? 0 : 1);
+  } catch (error) {
+    if (options.json) {
+      console.log(JSON.stringify({
+        success: false,
+        error: error.message,
+        timestamp: new Date().toISOString()
+      }, null, 2));
+    } else {
+      console.error(`\nError: ${error.message}`);
+      if (options.verbose) {
+        console.error(`Stack: ${error.stack}`);
+      }
+    }
+    process.exit(1);
+  }
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  deployApplication();
+}
+
+export { deployApplication };

package/src/scripts/coolify-list-resources.js

@@ -0,0 +1,199 @@
+#!/usr/bin/env node
+
+/**
+ * Coolify Resource Listing Script
+ * List servers, projects, applications, databases, or services
+ */
+
+import { CoolifyUtils } from '../lib/coolify-utils.js';
+
+const args = process.argv.slice(2);
+
+const options = {
+  type: null,
+  json: args.includes('--json'),
+  detailed: args.includes('--detailed') || args.includes('-d')
+};
+
+// Parse type argument
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === '--type' && args[i + 1]) {
+    options.type = args[i + 1];
+  }
+}
+
+if (!options.type || args.includes('--help') || args.includes('-h')) {
+  console.log(`
+Usage: coolify-list-resources --type <resource-type> [options]
+
+Resource Types:
+  servers       List all servers
+  projects      List all projects
+  applications  List all applications
+  databases     List all databases
+  services      List all services
+  all           List all resources
+
+Options:
+  --json        Output in JSON format
+  --detailed    Show detailed information
+  -d            Alias for --detailed
+  --help        Show this help
+  -h            Alias for --help
+
+Examples:
+  node src/scripts/coolify-list-resources.js --type servers
+  node src/scripts/coolify-list-resources.js --type applications --detailed
+  node src/scripts/coolify-list-resources.js --type all --json
+`);
+  process.exit(0);
+}
+
+async function listResources() {
+  try {
+    const coolify = new CoolifyUtils();
+    let data = {};
+
+    switch (options.type) {
+      case 'servers':
+        data.servers = await coolify.listServers();
+        break;
+      case 'projects':
+        data.projects = await coolify.listProjects();
+        break;
+      case 'applications':
+        data.applications = await coolify.listApplications();
+        break;
+      case 'databases':
+        data.databases = await coolify.listDatabases();
+        break;
+      case 'services':
+        data.services = await coolify.listServices();
+        break;
+      case 'all':
+        [data.servers, data.projects, data.applications, data.databases, data.services] = await Promise.all([
+          coolify.listServers(),
+          coolify.listProjects(),
+          coolify.listApplications(),
+          coolify.listDatabases(),
+          coolify.listServices()
+        ]);
+        break;
+      default:
+        console.error(`Unknown resource type: ${options.type}`);
+        process.exit(1);
+    }
+
+    if (options.json) {
+      console.log(JSON.stringify(data, null, 2));
+      process.exit(0);
+    }
+
+    // Format output
+    console.log('Coolify Resources');
+    console.log('='.repeat(60));
+
+    if (data.servers) {
+      console.log('\nServers:');
+      console.log('-'.repeat(60));
+      if (data.servers.length === 0) {
+        console.log('  No servers found');
+      } else {
+        coolify.formatServerList(data.servers).forEach(s => {
+          console.log(`  ${s.name}`);
+          if (options.detailed) {
+            console.log(`    UUID: ${s.uuid}`);
+            console.log(`    IP: ${s.ip}`);
+            console.log(`    Status: ${s.status}`);
+            console.log(`    Usable: ${s.usable}`);
+            console.log(`    Description: ${s.description}`);
+          }
+        });
+      }
+    }
+
+    if (data.projects) {
+      console.log('\nProjects:');
+      console.log('-'.repeat(60));
+      if (data.projects.length === 0) {
+        console.log('  No projects found');
+      } else {
+        data.projects.forEach(p => {
+          console.log(`  ${p.name}`);
+          if (options.detailed) {
+            console.log(`    UUID: ${p.uuid}`);
+            console.log(`    ID: ${p.id}`);
+            console.log(`    Description: ${p.description || 'No description'}`);
+          }
+        });
+      }
+    }
+
+    if (data.applications) {
+      console.log('\nApplications:');
+      console.log('-'.repeat(60));
+      if (data.applications.length === 0) {
+        console.log('  No applications found');
+      } else {
+        coolify.formatApplicationList(data.applications).forEach(a => {
+          console.log(`  ${a.name}`);
+          if (options.detailed) {
+            console.log(`    UUID: ${a.uuid}`);
+            console.log(`    Status: ${a.status}`);
+            console.log(`    URL: ${a.url}`);
+            console.log(`    Project: ${a.project}`);
+          }
+        });
+      }
+    }
+
+    if (data.databases) {
+      console.log('\nDatabases:');
+      console.log('-'.repeat(60));
+      if (data.databases.length === 0) {
+        console.log('  No databases found');
+      } else {
+        data.databases.forEach(db => {
+          console.log(`  ${db.name}`);
+          if (options.detailed) {
+            console.log(`    UUID: ${db.uuid}`);
+            console.log(`    Type: ${db.type}`);
+            console.log(`    Status: ${db.status || 'Unknown'}`);
+          }
+        });
+      }
+    }
+
+    if (data.services) {
+      console.log('\nServices:');
+      console.log('-'.repeat(60));
+      if (data.services.length === 0) {
+        console.log('  No services found');
+      } else {
+        data.services.forEach(svc => {
+          console.log(`  ${svc.name}`);
+          if (options.detailed) {
+            console.log(`    UUID: ${svc.uuid}`);
+            console.log(`    Status: ${svc.status || 'Unknown'}`);
+          }
+        });
+      }
+    }
+
+    console.log('\n' + '='.repeat(60));
+    process.exit(0);
+  } catch (error) {
+    if (options.json) {
+      console.log(JSON.stringify({ success: false, error: error.message }, null, 2));
+    } else {
+      console.error(`Error: ${error.message}`);
+    }
+    process.exit(1);
+  }
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  listResources();
+}
+
+export { listResources };