k3s-deployer 0.1.0

package/src/detect/index.cjs

@@ -0,0 +1,461 @@
+const path = require('node:path');
+const {
+  exists,
+  listImmediateDirectories,
+  posixRelative,
+  readIfExists,
+  readJsonIfExists,
+  slugify,
+  uniqueBy,
+} = require('../shared/utils.cjs');
+const { deriveSourceName, withLocalRepository } = require('../shared/source.cjs');
+
+const BACKEND_FRAMEWORKS = new Set([
+  'django',
+  'nestjs',
+  'springboot',
+  'gin',
+  'echo',
+  'fiber',
+  'axum',
+  'actix-web',
+  'rails',
+  'sinatra',
+]);
+
+const FRONTEND_FRAMEWORKS = new Set(['react', 'nextjs', 'vue', 'angular']);
+
+const PRIMARY_DATASTORES = new Set(['postgresql', 'mysql', 'sqlite', 'mongodb']);
+
+async function detectPackageManager(rootPath) {
+  if (await exists(path.join(rootPath, 'pnpm-lock.yaml'))) {
+    return 'pnpm';
+  }
+  if (await exists(path.join(rootPath, 'yarn.lock'))) {
+    return 'yarn';
+  }
+  return 'npm';
+}
+
+function packageManagerCommands(manager, task) {
+  if (manager === 'yarn') {
+    if (task === 'install') {
+      return ['yarn', 'install', '--frozen-lockfile'];
+    }
+    return ['yarn', task];
+  }
+  if (manager === 'pnpm') {
+    if (task === 'install') {
+      return ['pnpm', 'install', '--frozen-lockfile'];
+    }
+    return ['pnpm', task];
+  }
+  if (task === 'install') {
+    return ['npm', 'install'];
+  }
+  return ['npm', 'run', task];
+}
+
+function resolveUnitBuild(framework, packageManager) {
+  if (framework === 'react') {
+    return {
+      install: packageManagerCommands(packageManager, 'install'),
+      build: packageManagerCommands(packageManager, 'build'),
+      start: ['npx', 'serve', '-s', 'dist', '-l', '3000'],
+      packageManager,
+    };
+  }
+  if (framework === 'nextjs') {
+    return {
+      install: packageManagerCommands(packageManager, 'install'),
+      build: packageManagerCommands(packageManager, 'build'),
+      start: packageManagerCommands(packageManager, 'start'),
+      packageManager,
+    };
+  }
+  if (framework === 'vue') {
+    return {
+      install: packageManagerCommands(packageManager, 'install'),
+      build: packageManagerCommands(packageManager, 'build'),
+      start: ['npx', 'serve', '-s', 'dist', '-l', '3000'],
+      packageManager,
+    };
+  }
+  if (framework === 'angular') {
+    return {
+      install: packageManagerCommands(packageManager, 'install'),
+      build: packageManagerCommands(packageManager, 'build'),
+      start: ['npx', 'http-server', 'dist', '-p', '3000'],
+      packageManager,
+    };
+  }
+  if (framework === 'nestjs') {
+    return {
+      install: packageManagerCommands(packageManager, 'install'),
+      build: packageManagerCommands(packageManager, 'build'),
+      start: ['node', 'dist/main.js'],
+      packageManager,
+    };
+  }
+  if (framework === 'django') {
+    return {
+      install: ['pip', 'install', '-r', 'requirements.txt'],
+      start: ['python', 'manage.py', 'runserver', '0.0.0.0:8000'],
+    };
+  }
+  if (framework === 'springboot') {
+    return {
+      install: ['sh', '-lc', './mvnw dependency:go-offline || mvn dependency:go-offline'],
+      build: ['sh', '-lc', './mvnw package -DskipTests || mvn package -DskipTests'],
+      start: ['sh', '-lc', 'java -jar $(find target build/libs -name "*.jar" | head -n 1)'],
+    };
+  }
+  if (framework === 'gin' || framework === 'echo' || framework === 'fiber') {
+    return {
+      install: ['go', 'mod', 'download'],
+      build: ['go', 'build', '-o', 'app'],
+      start: ['./app'],
+    };
+  }
+  if (framework === 'axum' || framework === 'actix-web') {
+    return {
+      install: ['cargo', 'fetch'],
+      build: ['cargo', 'build', '--release'],
+      start: ['sh', '-lc', './target/release/$(basename $(pwd) | tr -c "a-zA-Z0-9" "-")'],
+    };
+  }
+  if (framework === 'rails') {
+    return {
+      install: ['bundle', 'install'],
+      start: ['bundle', 'exec', 'rails', 'server', '-b', '0.0.0.0', '-p', '3000'],
+    };
+  }
+  if (framework === 'sinatra') {
+    return {
+      install: ['bundle', 'install'],
+      start: ['bundle', 'exec', 'ruby', 'app.rb', '-o', '0.0.0.0', '-p', '4567'],
+    };
+  }
+  if (framework === 'android') {
+    return {
+      install: ['sh', '-lc', './gradlew tasks >/dev/null'],
+      build: ['sh', '-lc', './gradlew assembleRelease'],
+    };
+  }
+  return {
+    install: ['flutter', 'pub', 'get'],
+    build: ['flutter', 'build', 'apk', '--release'],
+  };
+}
+
+function resolveLanguage(framework) {
+  if (framework === 'django') {
+    return 'python';
+  }
+  if (framework === 'springboot') {
+    return 'java';
+  }
+  if (framework === 'gin' || framework === 'echo' || framework === 'fiber') {
+    return 'go';
+  }
+  if (framework === 'axum' || framework === 'actix-web') {
+    return 'rust';
+  }
+  if (framework === 'rails' || framework === 'sinatra') {
+    return 'ruby';
+  }
+  if (framework === 'android' || framework === 'flutter') {
+    return 'mobile';
+  }
+  return 'javascript';
+}
+
+function resolvePort(framework) {
+  if (framework === 'django') {
+    return 8000;
+  }
+  if (framework === 'springboot') {
+    return 8080;
+  }
+  if (framework === 'gin' || framework === 'echo' || framework === 'fiber') {
+    return 8080;
+  }
+  if (framework === 'sinatra') {
+    return 4567;
+  }
+  return 3000;
+}
+
+async function detectFrameworkAtRoot(rootPath) {
+  const packageJson = await readJsonIfExists(path.join(rootPath, 'package.json'));
+  const dependencies = {
+    ...(packageJson?.dependencies || {}),
+    ...(packageJson?.devDependencies || {}),
+  };
+  const packageManager = await detectPackageManager(rootPath);
+
+  if (dependencies['@nestjs/core']) {
+    return { role: 'backend', framework: 'nestjs', packageManager };
+  }
+  if (dependencies.next) {
+    return { role: 'frontend', framework: 'nextjs', packageManager };
+  }
+  if (dependencies.react && dependencies['react-dom']) {
+    return { role: 'frontend', framework: 'react', packageManager };
+  }
+  if (dependencies.vue) {
+    return { role: 'frontend', framework: 'vue', packageManager };
+  }
+  if (dependencies['@angular/core'] || (await exists(path.join(rootPath, 'angular.json')))) {
+    return { role: 'frontend', framework: 'angular', packageManager };
+  }
+
+  const requirements = (await readIfExists(path.join(rootPath, 'requirements.txt'))) || '';
+  const pyproject = (await readIfExists(path.join(rootPath, 'pyproject.toml'))) || '';
+  if ((await exists(path.join(rootPath, 'manage.py'))) && /django/i.test(`${requirements}\n${pyproject}`)) {
+    return { role: 'backend', framework: 'django' };
+  }
+
+  const pom = (await readIfExists(path.join(rootPath, 'pom.xml'))) || '';
+  const gradle = `${(await readIfExists(path.join(rootPath, 'build.gradle'))) || ''}\n${
+    (await readIfExists(path.join(rootPath, 'build.gradle.kts'))) || ''
+  }`;
+  if (/spring-boot/i.test(`${pom}\n${gradle}`)) {
+    return { role: 'backend', framework: 'springboot' };
+  }
+
+  const goMod = (await readIfExists(path.join(rootPath, 'go.mod'))) || '';
+  if (/gin-gonic\/gin/i.test(goMod)) {
+    return { role: 'backend', framework: 'gin' };
+  }
+  if (/labstack\/echo/i.test(goMod)) {
+    return { role: 'backend', framework: 'echo' };
+  }
+  if (/gofiber\/fiber/i.test(goMod)) {
+    return { role: 'backend', framework: 'fiber' };
+  }
+
+  const cargoToml = (await readIfExists(path.join(rootPath, 'Cargo.toml'))) || '';
+  if (/^\s*axum\s*=|axum\s*=\s*\{/m.test(cargoToml)) {
+    return { role: 'backend', framework: 'axum' };
+  }
+  if (/^\s*actix-web\s*=|actix-web\s*=\s*\{/m.test(cargoToml)) {
+    return { role: 'backend', framework: 'actix-web' };
+  }
+
+  const gemfile = (await readIfExists(path.join(rootPath, 'Gemfile'))) || '';
+  if (/gem ['"]rails['"]/i.test(gemfile)) {
+    return { role: 'backend', framework: 'rails' };
+  }
+  if (/gem ['"]sinatra['"]/i.test(gemfile)) {
+    return { role: 'backend', framework: 'sinatra' };
+  }
+
+  const flutterPubspec = (await readIfExists(path.join(rootPath, 'pubspec.yaml'))) || '';
+  if (/^\s*flutter:\s*$/m.test(flutterPubspec) || /sdk:\s*flutter/m.test(flutterPubspec)) {
+    return { role: 'mobile', framework: 'flutter' };
+  }
+
+  const hasAndroidManifest = await exists(path.join(rootPath, 'app', 'src', 'main', 'AndroidManifest.xml'));
+  const hasGradle = (await exists(path.join(rootPath, 'app', 'build.gradle'))) || (await exists(path.join(rootPath, 'app', 'build.gradle.kts')));
+  if (hasAndroidManifest && hasGradle) {
+    return { role: 'mobile', framework: 'android' };
+  }
+
+  return null;
+}
+
+async function detectUnit(repoRoot, relativeRoot) {
+  const rootPath = relativeRoot === '.' ? repoRoot : path.join(repoRoot, relativeRoot);
+  const frameworkMatch = await detectFrameworkAtRoot(rootPath);
+  if (!frameworkMatch) {
+    return null;
+  }
+
+  const framework = frameworkMatch.framework;
+  return {
+    id: slugify(relativeRoot === '.' ? framework : `${path.basename(relativeRoot)}-${framework}`),
+    role: frameworkMatch.role,
+    framework,
+    root: relativeRoot,
+    language: resolveLanguage(framework),
+    port: frameworkMatch.role === 'mobile' ? undefined : resolvePort(framework),
+    build: resolveUnitBuild(framework, frameworkMatch.packageManager),
+  };
+}
+
+async function discoverCandidateRoots(repoRoot) {
+  const immediateDirectories = await listImmediateDirectories(repoRoot);
+  const priority = ['frontend', 'backend', 'client', 'server'];
+  const ordered = ['.', ...priority.filter((dir) => immediateDirectories.includes(dir))];
+  for (const directory of immediateDirectories) {
+    if (!ordered.includes(directory)) {
+      ordered.push(directory);
+    }
+  }
+  return ordered;
+}
+
+async function detectDatastores(repoRoot, units, overrides) {
+  const findings = [];
+  const candidateFiles = ['.env', '.env.local', '.env.example', 'application.yml', 'application.yaml', 'application.properties', 'settings.py', 'config/database.yml', 'go.mod', 'Cargo.toml', 'Gemfile', 'requirements.txt', 'pyproject.toml', 'package.json', 'pom.xml', 'build.gradle', 'build.gradle.kts'];
+  const searchRoots = ['.', ...units.map((unit) => unit.root).filter((root) => root !== '.')];
+  const seenPaths = new Set();
+
+  for (const root of searchRoots) {
+    const basePath = root === '.' ? repoRoot : path.join(repoRoot, root);
+    for (const fileName of candidateFiles) {
+      const filePath = path.join(basePath, fileName);
+      if (seenPaths.has(filePath) || !(await exists(filePath))) {
+        continue;
+      }
+      seenPaths.add(filePath);
+      const content = (await readIfExists(filePath)) || '';
+      const source = fileName.startsWith('.env') ? 'env' : fileName === 'package.json' ? 'dependency' : 'config';
+
+      if (
+        /postgres(ql)?:\/\//i.test(content) ||
+        /jdbc:postgresql/i.test(content) ||
+        /postgresql/i.test(content) ||
+        /"pg"\s*:/i.test(content) ||
+        /lib\/pq|jackc\/pgx/i.test(content)
+      ) {
+        findings.push({ kind: 'postgresql', role: 'primary', source });
+      }
+      if (/mysql:\/\//i.test(content) || /jdbc:mysql/i.test(content) || /mysqlclient|pymysql|mysql2|go-sql-driver\/mysql/i.test(content)) {
+        findings.push({ kind: 'mysql', role: 'primary', source });
+      }
+      if (/sqlite/i.test(content) || /better-sqlite3|sqlite3/i.test(content)) {
+        findings.push({ kind: 'sqlite', role: 'primary', source });
+      }
+      if (/mongodb(\+srv)?:\/\//i.test(content) || /mongoose|mongodb|mongo-driver|spring\.data\.mongodb/i.test(content)) {
+        findings.push({ kind: 'mongodb', role: 'primary', source });
+      }
+      if (/redis:\/\//i.test(content) || /ioredis|[^a-z]redis[^a-z]|spring\.data\.redis/i.test(content)) {
+        findings.push({ kind: 'redis', role: 'auxiliary', source });
+      }
+      if (/elasticsearch|@elastic\/elasticsearch|spring\.elasticsearch|go-elasticsearch/i.test(content)) {
+        findings.push({ kind: 'elasticsearch', role: 'auxiliary', source });
+      }
+    }
+  }
+
+  const uniqueFindings = uniqueBy(findings, (finding) => finding.kind);
+  const primaryKinds = uniqueFindings.filter((finding) => PRIMARY_DATASTORES.has(finding.kind));
+  if (primaryKinds.length > 1) {
+    const preferred = overrides && overrides.primaryDatastore;
+    if (!preferred) {
+      throw new Error(`Multiple primary datastores detected: ${primaryKinds.map((item) => item.kind).join(', ')}`);
+    }
+    return uniqueFindings.map((finding) => ({
+      ...finding,
+      role: finding.kind === preferred || !PRIMARY_DATASTORES.has(finding.kind) ? finding.role : 'auxiliary',
+    }));
+  }
+  return uniqueFindings;
+}
+
+function isNestedRoot(parentRoot, childRoot) {
+  if (parentRoot === childRoot) {
+    return false;
+  }
+  if (parentRoot === '.') {
+    return childRoot !== '.';
+  }
+  return childRoot.startsWith(`${parentRoot}/`);
+}
+
+function normalizeUnits(units) {
+  return units.filter((unit) => {
+    if (unit.role !== 'mobile') {
+      return true;
+    }
+
+    const parentMobile = units.find((candidate) => {
+      if (candidate === unit || candidate.role !== 'mobile') {
+        return false;
+      }
+      if (!isNestedRoot(candidate.root, unit.root)) {
+        return false;
+      }
+      if (candidate.framework === 'flutter') {
+        return true;
+      }
+      return candidate.root.length < unit.root.length;
+    });
+
+    return !parentMobile;
+  });
+}
+
+function classifyLayout(units) {
+  const backends = units.filter((unit) => BACKEND_FRAMEWORKS.has(unit.framework));
+  const frontends = units.filter((unit) => FRONTEND_FRAMEWORKS.has(unit.framework));
+  const mobile = units.filter((unit) => unit.role === 'mobile');
+
+  if (backends.length > 1) {
+    throw new Error(`Multiple backend roots detected: ${backends.map((unit) => unit.root).join(', ')}`);
+  }
+  if (frontends.length > 1) {
+    throw new Error(`Multiple frontend roots detected: ${frontends.map((unit) => unit.root).join(', ')}`);
+  }
+  if (mobile.length > 1) {
+    throw new Error(`Multiple mobile roots detected: ${mobile.map((unit) => unit.root).join(', ')}`);
+  }
+  if (backends.length === 1 && frontends.length === 1) {
+    return 'monorepo';
+  }
+  if (backends.length + frontends.length === 1) {
+    return 'single-role';
+  }
+  if (backends.length === 0 && frontends.length === 0 && mobile.length === 1) {
+    return 'single-role';
+  }
+  throw new Error('Unable to classify repository layout');
+}
+
+async function inspectRepository(source, overrides = {}, config = {}) {
+  return withLocalRepository(source, config.workspaceRoot, async (repoRoot) => {
+    const candidateRoots = await discoverCandidateRoots(repoRoot);
+    const units = [];
+
+    for (const relativeRoot of candidateRoots) {
+      const unit = await detectUnit(repoRoot, relativeRoot);
+      if (!unit) {
+        continue;
+      }
+      units.push(unit);
+    }
+
+    if (units.length === 0) {
+      throw new Error('No supported deployable units were detected');
+    }
+
+    const uniqueUnits = normalizeUnits(
+      uniqueBy(units, (unit) => `${unit.role}:${unit.root}`),
+    );
+    const datastores = await detectDatastores(repoRoot, uniqueUnits, overrides);
+    const layout = classifyLayout(uniqueUnits);
+    const projectSlug = slugify(overrides.projectName || deriveSourceName(source));
+    const warnings = [];
+
+    if (!datastores.some((item) => item.role === 'primary')) {
+      warnings.push('No primary datastore was detected');
+    }
+
+    return {
+      projectSlug,
+      layout,
+      units: uniqueUnits.map((unit) => ({
+        ...unit,
+        root: unit.root === '' ? '.' : unit.root,
+      })),
+      datastores,
+      warnings,
+    };
+  });
+}
+
+module.exports = {
+  inspectRepository,
+};

package/src/dns/cloudflare.cjs

@@ -0,0 +1,163 @@
+const DEFAULT_API_BASE_URL = 'https://api.cloudflare.com/client/v4';
+
+function normalizeCloudflareDns(config = {}) {
+  return {
+    apiToken: config.apiToken || undefined,
+    apiKey: config.apiKey || undefined,
+    email: config.email || undefined,
+    zoneId: config.zoneId || undefined,
+    targetIp: config.targetIp || undefined,
+    proxied: Boolean(config.proxied),
+  };
+}
+
+function hasCredentials(config) {
+  return Boolean(config.apiToken || (config.apiKey && config.email));
+}
+
+function createHeaders(config) {
+  const headers = {
+    'content-type': 'application/json',
+  };
+
+  if (config.apiToken) {
+    headers.authorization = `Bearer ${config.apiToken}`;
+    return headers;
+  }
+
+  headers['x-auth-email'] = config.email;
+  headers['x-auth-key'] = config.apiKey;
+  return headers;
+}
+
+async function parseResponse(response) {
+  const text = await response.text();
+
+  if (!text) {
+    return {};
+  }
+
+  try {
+    return JSON.parse(text);
+  } catch {
+    return { raw: text };
+  }
+}
+
+async function requestJson(url, options = {}) {
+  const response = await fetch(url, options);
+  const payload = await parseResponse(response);
+
+  if (!response.ok || payload.success === false) {
+    const message =
+      payload?.errors?.[0]?.message ||
+      payload?.errors?.[0]?.error ||
+      payload?.messages?.[0]?.message ||
+      payload?.raw ||
+      `${response.status} ${response.statusText}`;
+    throw new Error(message);
+  }
+
+  return payload;
+}
+
+async function resolveZoneId(domain, config) {
+  if (config.zoneId) {
+    return config.zoneId;
+  }
+
+  const parts = String(domain || '')
+    .split('.')
+    .filter(Boolean);
+
+  if (parts.length < 2) {
+    throw new Error(`Invalid domain: ${domain}`);
+  }
+
+  const headers = createHeaders(config);
+
+  for (let index = 0; index < parts.length - 1; index += 1) {
+    const zoneName = parts.slice(index).join('.');
+    const url = new URL(`${DEFAULT_API_BASE_URL}/zones`);
+    url.searchParams.set('name', zoneName);
+
+    const payload = await requestJson(url, {
+      method: 'GET',
+      headers,
+    });
+
+    if (Array.isArray(payload.result) && payload.result[0]?.id) {
+      return payload.result[0].id;
+    }
+  }
+
+  throw new Error(`Zone ID not found for domain: ${domain}`);
+}
+
+async function upsertCloudflareDnsRecord(input) {
+  const config = normalizeCloudflareDns(input);
+  const domain = String(input.domain || '').trim().toLowerCase();
+  const targetIp = String(config.targetIp || '').trim();
+
+  if (!domain) {
+    throw new Error('A domain is required to publish Cloudflare DNS');
+  }
+
+  if (!targetIp) {
+    throw new Error(`A target IP is required to publish Cloudflare DNS for ${domain}`);
+  }
+
+  if (!hasCredentials(config)) {
+    throw new Error('Cloudflare credentials are not configured');
+  }
+
+  const zoneId = await resolveZoneId(domain, config);
+  const headers = createHeaders(config);
+  const listUrl = new URL(
+    `${DEFAULT_API_BASE_URL}/zones/${zoneId}/dns_records`,
+  );
+  listUrl.searchParams.set('type', 'A');
+  listUrl.searchParams.set('name', domain);
+
+  const existing = await requestJson(listUrl, {
+    method: 'GET',
+    headers,
+  });
+
+  const body = JSON.stringify({
+    type: 'A',
+    name: domain,
+    content: targetIp,
+    ttl: 1,
+    proxied: Boolean(config.proxied),
+  });
+
+  if (Array.isArray(existing.result) && existing.result[0]?.id) {
+    await requestJson(
+      `${DEFAULT_API_BASE_URL}/zones/${zoneId}/dns_records/${existing.result[0].id}`,
+      {
+        method: 'PUT',
+        headers,
+        body,
+      },
+    );
+  } else {
+    await requestJson(`${DEFAULT_API_BASE_URL}/zones/${zoneId}/dns_records`, {
+      method: 'POST',
+      headers,
+      body,
+    });
+  }
+
+  return {
+    provider: 'cloudflare',
+    type: 'A',
+    domain,
+    targetIp,
+    proxied: Boolean(config.proxied),
+  };
+}
+
+module.exports = {
+  upsertCloudflareDnsRecord,
+};