k3s-deployer 0.1.0

package/src/plan/index.cjs

@@ -0,0 +1,200 @@
+const { createConfigMapManifest, createDatabaseManifests, createDeploymentManifest, createIngressManifest, createSecretManifest, createServiceManifest } = require('../templates/manifests.cjs');
+const { filterPublicEnv, slugify, toDatabaseName } = require('../shared/utils.cjs');
+
+function createGeneratedEnv(inspection, overrides = {}) {
+  const backendEnv = { ...(overrides.privateEnv || {}) };
+  const frontendPublic = filterPublicEnv(overrides.publicEnv || {});
+  const primaryStore = inspection.datastores.find((item) => item.role === 'primary');
+  const projectSlug = inspection.projectSlug;
+  const dbName = toDatabaseName(projectSlug);
+
+  if (primaryStore) {
+    if (primaryStore.kind === 'postgresql') {
+      backendEnv.DATABASE_URL = `postgresql://app:apppass@${projectSlug}-postgresql:5432/${dbName}`;
+      backendEnv.DB_HOST = `${projectSlug}-postgresql`;
+      backendEnv.DB_PORT = '5432';
+      backendEnv.DB_NAME = dbName;
+      backendEnv.DB_USER = 'app';
+      backendEnv.DB_PASSWORD = 'apppass';
+      backendEnv.SPRING_DATASOURCE_URL = `jdbc:postgresql://${projectSlug}-postgresql:5432/${dbName}`;
+      backendEnv.SPRING_DATASOURCE_USERNAME = 'app';
+      backendEnv.SPRING_DATASOURCE_PASSWORD = 'apppass';
+    }
+    if (primaryStore.kind === 'mysql') {
+      backendEnv.DATABASE_URL = `mysql://app:apppass@${projectSlug}-mysql:3306/${dbName}`;
+      backendEnv.DB_HOST = `${projectSlug}-mysql`;
+      backendEnv.DB_PORT = '3306';
+      backendEnv.DB_NAME = dbName;
+      backendEnv.DB_USER = 'app';
+      backendEnv.DB_PASSWORD = 'apppass';
+      backendEnv.SPRING_DATASOURCE_URL = `jdbc:mysql://${projectSlug}-mysql:3306/${dbName}`;
+      backendEnv.SPRING_DATASOURCE_USERNAME = 'app';
+      backendEnv.SPRING_DATASOURCE_PASSWORD = 'apppass';
+    }
+    if (primaryStore.kind === 'mongodb') {
+      backendEnv.DATABASE_URL = `mongodb://${projectSlug}-mongodb:27017/${dbName}`;
+      backendEnv.MONGODB_URL = `mongodb://${projectSlug}-mongodb:27017/${dbName}`;
+      backendEnv.MONGO_URL = `mongodb://${projectSlug}-mongodb:27017/${dbName}`;
+    }
+    if (primaryStore.kind === 'sqlite') {
+      backendEnv.DATABASE_URL = `sqlite:////data/${dbName}.sqlite3`;
+      backendEnv.SQLITE_PATH = `/data/${dbName}.sqlite3`;
+    }
+  }
+
+  if (inspection.datastores.some((item) => item.kind === 'redis')) {
+    backendEnv.REDIS_URL = `redis://${projectSlug}-redis:6379`;
+    backendEnv.REDIS_HOST = `${projectSlug}-redis`;
+    backendEnv.REDIS_PORT = '6379';
+    backendEnv.SPRING_DATA_REDIS_HOST = `${projectSlug}-redis`;
+    backendEnv.SPRING_DATA_REDIS_PORT = '6379';
+  }
+
+  if (inspection.datastores.some((item) => item.kind === 'elasticsearch')) {
+    backendEnv.ELASTICSEARCH_URL = `http://${projectSlug}-elasticsearch:9200`;
+    backendEnv.SPRING_ELASTICSEARCH_URIS = `http://${projectSlug}-elasticsearch:9200`;
+  }
+
+  const frontendUnit = inspection.units.find((unit) => unit.role === 'frontend');
+  if (frontendUnit && overrides.domain) {
+    const apiUrl = overrides.apiUrl || (inspection.layout === 'single-role' ? `https://${overrides.domain}` : `https://${overrides.domain}`);
+    if (frontendUnit.framework === 'nextjs') {
+      frontendPublic.NEXT_PUBLIC_API_URL = frontendPublic.NEXT_PUBLIC_API_URL || apiUrl;
+    } else if (frontendUnit.framework === 'react' || frontendUnit.framework === 'vue') {
+      frontendPublic.VITE_API_URL = frontendPublic.VITE_API_URL || apiUrl;
+      frontendPublic.REACT_APP_API_URL = frontendPublic.REACT_APP_API_URL || apiUrl;
+    }
+  }
+
+  return {
+    backend: backendEnv,
+    frontendPublic,
+  };
+}
+
+function resolvePublicUnits(inspection) {
+  if (inspection.layout === 'monorepo') {
+    const frontend = inspection.units.find((unit) => unit.role === 'frontend');
+    return frontend ? [frontend.id] : [];
+  }
+  return inspection.units.filter((unit) => unit.role !== 'mobile').map((unit) => unit.id);
+}
+
+function buildPlanInternals(inspection, overrides = {}, config = {}) {
+  const registryHost = overrides.registryHost || config.registryHost || 'localhost:5000';
+  const namespace = slugify(overrides.namespace || 'default') || 'default';
+  const basePort = Number(overrides.serviceBasePort || 30080);
+  const publicUnits = resolvePublicUnits(inspection);
+  const units = inspection.units
+    .filter((unit) => unit.role !== 'mobile')
+    .map((unit, index) => ({
+      ...unit,
+      name: slugify(`${inspection.projectSlug}-${unit.id}`),
+      image: `${registryHost}/${slugify(`${inspection.projectSlug}-${unit.id}`)}:latest`,
+      public: publicUnits.includes(unit.id),
+      nodePort: publicUnits.includes(unit.id) && !overrides.domain ? basePort + index : null,
+      secretName: unit.role === 'backend' ? `${inspection.projectSlug}-backend-env` : null,
+      configMapName: unit.role === 'frontend' ? `${inspection.projectSlug}-frontend-env` : null,
+    }));
+  return {
+    registryHost,
+    namespace,
+    units,
+  };
+}
+
+function createDeploymentPlan(inspection, overrides = {}, config = {}) {
+  const env = createGeneratedEnv(inspection, overrides);
+  const internals = buildPlanInternals(inspection, overrides, config);
+  const secretManifest = createSecretManifest(`${inspection.projectSlug}-backend-env`, internals.namespace, env.backend);
+  const configMapManifest = createConfigMapManifest(
+    `${inspection.projectSlug}-frontend-env`,
+    internals.namespace,
+    env.frontendPublic,
+  );
+
+  const data = inspection.datastores.flatMap((datastore) =>
+    createDatabaseManifests({
+      kind: datastore.kind,
+      namespace: internals.namespace,
+      projectSlug: inspection.projectSlug,
+    }),
+  );
+
+  const apps = [];
+  if (secretManifest) {
+    apps.push(secretManifest);
+  }
+  if (configMapManifest) {
+    apps.push(configMapManifest);
+  }
+
+  for (const unit of internals.units) {
+    apps.push(
+      createDeploymentManifest({
+        name: unit.name,
+        namespace: internals.namespace,
+        image: unit.image,
+        port: unit.port || 3000,
+        secretName: unit.secretName,
+        configMapName: unit.configMapName,
+        volumeClaimName:
+          inspection.datastores.find((item) => item.kind === 'sqlite' && item.role === 'primary') && unit.role === 'backend'
+            ? `${inspection.projectSlug}-sqlite-pvc`
+            : null,
+        volumeMountPath:
+          inspection.datastores.find((item) => item.kind === 'sqlite' && item.role === 'primary') && unit.role === 'backend'
+            ? '/data'
+            : null,
+      }),
+    );
+    apps.push(
+      createServiceManifest({
+        name: unit.name,
+        namespace: internals.namespace,
+        port: 80,
+        targetPort: unit.port || 3000,
+        nodePort: unit.nodePort,
+      }),
+    );
+    if (overrides.domain && unit.public) {
+      apps.push(
+        createIngressManifest({
+          name: `${unit.name}-ingress`,
+          namespace: internals.namespace,
+          domain: overrides.domain,
+          serviceName: unit.name,
+          servicePort: 80,
+        }),
+      );
+    }
+  }
+
+  const mobileUnit = inspection.units.find((unit) => unit.role === 'mobile');
+  const mobile =
+    mobileUnit && mobileUnit.framework === 'android'
+      ? { framework: 'android', apkPath: `${mobileUnit.root}/app/build/outputs/apk/release/app-release.apk` }
+      : mobileUnit
+        ? { framework: 'flutter', apkPath: `${mobileUnit.root}/build/app/outputs/flutter-apk/app-release.apk` }
+        : undefined;
+
+  return {
+    inspection,
+    cluster: {
+      bootstrap: 'if-missing',
+      registryHost: internals.registryHost,
+      namespace: internals.namespace,
+    },
+    env,
+    manifests: {
+      apps,
+      data,
+    },
+    mobile,
+    resolved: internals,
+  };
+}
+
+module.exports = {
+  createDeploymentPlan,
+};

package/src/runtime/index.cjs

@@ -0,0 +1,16 @@
+const { LocalRunner } = require('./local-runner.cjs');
+const { SshRunner } = require('./ssh-runner.cjs');
+
+async function createRunner(target, config = {}) {
+  if (config.runnerFactory) {
+    return config.runnerFactory(target);
+  }
+  if (!target || target.kind === 'local') {
+    return new LocalRunner(target);
+  }
+  return new SshRunner(target);
+}
+
+module.exports = {
+  createRunner,
+};

package/src/runtime/local-runner.cjs

@@ -0,0 +1,69 @@
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { spawn } = require('node:child_process');
+
+class LocalRunner {
+  constructor(target = {}) {
+    this.target = target;
+  }
+
+  async run(command, options = {}) {
+    if (options.dryRun) {
+      return { stdout: '', stderr: '', code: 0 };
+    }
+    return new Promise((resolve, reject) => {
+      const child = spawn('bash', ['-lc', command], {
+        cwd: options.cwd,
+        env: { ...process.env, ...(options.env || {}) },
+      });
+      let stdout = '';
+      let stderr = '';
+
+      child.stdout.on('data', (chunk) => {
+        const text = chunk.toString();
+        stdout += text;
+        if (options.onStdout) {
+          options.onStdout(text);
+        }
+      });
+      child.stderr.on('data', (chunk) => {
+        const text = chunk.toString();
+        stderr += text;
+        if (options.onStderr) {
+          options.onStderr(text);
+        }
+      });
+      child.on('error', reject);
+      child.on('close', (code) => {
+        if (code !== 0 && !options.allowFailure) {
+          reject(new Error(stderr || stdout || `Command failed: ${command}`));
+          return;
+        }
+        resolve({ stdout, stderr, code });
+      });
+    });
+  }
+
+  async exists(filePath) {
+    try {
+      await fs.access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async writeFile(filePath, content) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, content, 'utf8');
+  }
+
+  async writeBase64File(filePath, contentBase64) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, Buffer.from(contentBase64, 'base64'));
+  }
+}
+
+module.exports = {
+  LocalRunner,
+};

package/src/runtime/ssh-runner.cjs

@@ -0,0 +1,206 @@
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { Client } = require('ssh2');
+const { shellQuote } = require('../shared/utils.cjs');
+
+const DEFAULT_SUDO_PROMPT_PATTERN = /\[sudo\] password for [^:]+:\s*/g;
+
+function normalizePrivateKey(privateKey) {
+  const normalized = String(privateKey || '')
+    .replace(/\r\n/g, '\n')
+    .replace(/\\n/g, '\n')
+    .trim();
+  return normalized ? `${normalized}\n` : '';
+}
+
+class SshRunner {
+  constructor(target) {
+    this.target = target;
+  }
+
+  getSudoPassword() {
+    return this.target.sudoPassword || this.target.password || null;
+  }
+
+  decorateCommand(command) {
+    const sudoPassword = this.getSudoPassword();
+    if (!sudoPassword || !command.includes('sudo ')) {
+      return command;
+    }
+
+    return command.replace(
+      /\bsudo\s+/g,
+      `printf '%s\\n' ${shellQuote(sudoPassword)} | sudo -S -p '' `,
+    );
+  }
+
+  async getConnectOptions() {
+    const connectOptions = {
+      host: this.target.host,
+      port: this.target.port || 22,
+      username: this.target.user,
+      readyTimeout: (this.target.connectTimeoutSec || 15) * 1000,
+      tryKeyboard: Boolean(this.target.password),
+      keepaliveInterval: 10000,
+      keepaliveCountMax: 30,
+    };
+
+    if (this.target.privateKey) {
+      connectOptions.privateKey = normalizePrivateKey(this.target.privateKey);
+    } else if (this.target.privateKeyPath) {
+      const privateKey = await fs.readFile(
+        path.resolve(this.target.privateKeyPath),
+        'utf8',
+      );
+      connectOptions.privateKey = normalizePrivateKey(privateKey);
+    }
+
+    if (this.target.password) {
+      connectOptions.password = this.target.password;
+    }
+
+    return connectOptions;
+  }
+
+  async run(command, options = {}) {
+    if (options.dryRun) {
+      return { stdout: '', stderr: '', code: 0 };
+    }
+
+    const decoratedCommand = this.decorateCommand(command);
+    const remoteCommand = `${options.cwd ? `cd ${shellQuote(options.cwd)} && ` : ''}${decoratedCommand}`;
+    const connectOptions = await this.getConnectOptions();
+    const timeoutMs =
+      options.timeoutMs || this.target.commandTimeoutMs || 15 * 60 * 1000;
+
+    return new Promise((resolve, reject) => {
+      const conn = new Client();
+      let stdout = '';
+      let stderr = '';
+      let settled = false;
+      const timer = setTimeout(() => {
+        finish(
+          new Error(`Remote command timed out after ${timeoutMs}ms: ${command}`),
+        );
+      }, timeoutMs);
+
+      const finish = (error, result) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        clearTimeout(timer);
+        conn.end();
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve(result);
+      };
+
+      conn
+        .on('ready', () => {
+          conn.exec(`bash -lc ${shellQuote(remoteCommand)}`, (error, stream) => {
+              if (error) {
+                finish(error);
+                return;
+              }
+
+              const handleChunk = (chunk, sink, callback) => {
+                const text = chunk.toString();
+                const normalizedText = text.replace(
+                  DEFAULT_SUDO_PROMPT_PATTERN,
+                  '',
+                );
+                if (normalizedText) {
+                  sink.value += normalizedText;
+                  if (callback) {
+                    callback(normalizedText);
+                  }
+                }
+              };
+
+              stream.on('close', (code) => {
+                if (code !== 0 && !options.allowFailure) {
+                  finish(
+                    new Error(
+                      stderr || stdout || `Remote command failed: ${command}`,
+                    ),
+                  );
+                  return;
+                }
+                finish(null, { stdout, stderr, code });
+              });
+
+              stream.on('data', (chunk) => {
+                handleChunk(
+                  chunk,
+                  {
+                    get value() {
+                      return stdout;
+                    },
+                    set value(nextValue) {
+                      stdout = nextValue;
+                    },
+                  },
+                  options.onStdout,
+                );
+              });
+
+              stream.stderr.on('data', (chunk) => {
+                handleChunk(
+                  chunk,
+                  {
+                    get value() {
+                      return stderr;
+                    },
+                    set value(nextValue) {
+                      stderr = nextValue;
+                    },
+                  },
+                  options.onStderr,
+                );
+              });
+            });
+        })
+        .on('keyboard-interactive', (_name, _instructions, _lang, prompts, cb) => {
+          if (!this.target.password) {
+            cb([]);
+            return;
+          }
+          cb(prompts.map(() => this.target.password));
+        })
+        .on('error', (error) => {
+          finish(error);
+        })
+        .connect(connectOptions);
+    });
+  }
+
+  async exists(filePath) {
+    const result = await this.run(
+      `[ -e ${shellQuote(filePath)} ] && echo yes || echo no`,
+      {
+        allowFailure: true,
+      },
+    );
+    return result.stdout.trim() === 'yes';
+  }
+
+  async writeFile(filePath, content) {
+    await this.run(`mkdir -p ${shellQuote(path.posix.dirname(filePath))}`);
+    await this.run(`cat > ${shellQuote(filePath)} <<'EOF'\n${content}\nEOF`);
+  }
+
+  async writeBase64File(filePath, contentBase64) {
+    const encodedPath = `${filePath}.k3s-deployer.b64`;
+    await this.run(`mkdir -p ${shellQuote(path.posix.dirname(filePath))}`);
+    await this.run(
+      `cat > ${shellQuote(encodedPath)} <<'EOF'\n${contentBase64}\nEOF\nbase64 -d ${shellQuote(encodedPath)} > ${shellQuote(filePath)}\nrm -f ${shellQuote(encodedPath)}`,
+    );
+  }
+}
+
+module.exports = {
+  SshRunner,
+};

package/src/shared/source.cjs

@@ -0,0 +1,145 @@
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const os = require('node:os');
+const { execFile } = require('node:child_process');
+const { promisify } = require('node:util');
+const { ensureDir, hashText, shellQuote, slugify } = require('./utils.cjs');
+
+const execFileAsync = promisify(execFile);
+
+function applyGitToken(url, token) {
+  if (!token) {
+    return url;
+  }
+  if (url.startsWith('https://')) {
+    return url.replace('https://', `https://${token}@`);
+  }
+  if (url.startsWith('git@github.com:')) {
+    return `https://${token}@github.com/${url.replace('git@github.com:', '')}`;
+  }
+  return url;
+}
+
+function deriveSourceName(source) {
+  if (source.kind === 'local') {
+    return path.basename(path.resolve(source.path));
+  }
+  if (source.fullName) {
+    return source.fullName.split('/').pop() || 'project';
+  }
+  return source.url.split('/').pop()?.replace(/\.git$/, '') || 'project';
+}
+
+function fingerprintSource(source) {
+  return hashText(
+    JSON.stringify({
+      kind: source.kind,
+      url: source.kind === 'git' ? source.url : path.resolve(source.path),
+      branch: source.kind === 'git' ? source.branch : source.branch || '',
+    }),
+  );
+}
+
+async function withLocalRepository(source, workspaceRoot, callback) {
+  if (source.kind === 'local') {
+    const localPath = path.resolve(source.path);
+    return callback(localPath);
+  }
+
+  const tempBase = workspaceRoot || os.tmpdir();
+  await ensureDir(tempBase);
+  const tempRoot = await fs.mkdtemp(path.join(tempBase, 'k3s-deployer-inspect-'));
+  const repoPath = path.join(tempRoot, slugify(deriveSourceName(source)) || 'repo');
+
+  try {
+    await execFileAsync(
+      'git',
+      ['clone', '--depth', '1', '--branch', source.branch, applyGitToken(source.url, source.accessToken), repoPath],
+      {
+        maxBuffer: 1024 * 1024 * 20,
+      },
+    );
+    return await callback(repoPath);
+  } finally {
+    await fs.rm(tempRoot, { recursive: true, force: true });
+  }
+}
+
+async function materializeLocalSource(source, workspaceRoot, releaseId) {
+  const targetRoot = path.join(workspaceRoot, releaseId);
+  await fs.rm(targetRoot, { recursive: true, force: true });
+  await ensureDir(workspaceRoot);
+  if (source.kind === 'local') {
+    await fs.cp(path.resolve(source.path), targetRoot, { recursive: true });
+    return targetRoot;
+  }
+  await execFileAsync(
+    'git',
+    ['clone', '--depth', '1', '--branch', source.branch, applyGitToken(source.url, source.accessToken), targetRoot],
+    {
+      maxBuffer: 1024 * 1024 * 20,
+    },
+  );
+  return targetRoot;
+}
+
+function resolveRemoteWorkspacePath(workspaceRoot, workspaceName) {
+  if (!workspaceRoot || workspaceRoot === '.' || workspaceRoot === './') {
+    return workspaceName;
+  }
+  return path.posix.join(workspaceRoot, workspaceName);
+}
+
+async function materializeRemoteGitSource(
+  source,
+  runner,
+  workspaceRoot,
+  releaseId,
+  options = {},
+) {
+  if (source.kind !== 'git') {
+    throw new Error('Local path sources require a local runtime target');
+  }
+
+  const workspacePath = resolveRemoteWorkspacePath(workspaceRoot, releaseId);
+  const remoteUrl = applyGitToken(source.url, source.accessToken);
+  const branchRef = `refs/heads/${source.branch}`;
+  const originBranchRef = `origin/${source.branch}`;
+  const gitPrefix = 'GIT_TERMINAL_PROMPT=0 GIT_ASKPASS=/bin/true';
+  if (workspaceRoot && workspaceRoot !== '.' && workspaceRoot !== './') {
+    await runner.run(`mkdir -p ${shellQuote(workspaceRoot)}`, {
+      onStdout: options.onLog,
+      onStderr: options.onLog,
+    });
+  }
+  await runner.run(
+    `if [ -d ${shellQuote(workspacePath)} ]; then
+  echo "Directory ${workspacePath} exists. Pulling latest changes..."
+  cd ${shellQuote(workspacePath)}
+  ${gitPrefix} git remote set-url origin ${shellQuote(remoteUrl)}
+  ${gitPrefix} git fetch --progress origin ${shellQuote(source.branch)}
+  if git show-ref --verify --quiet ${shellQuote(branchRef)}; then
+    git checkout ${shellQuote(source.branch)}
+  else
+    git checkout -b ${shellQuote(source.branch)} ${shellQuote(originBranchRef)}
+  fi
+  ${gitPrefix} git pull --progress origin ${shellQuote(source.branch)}
+else
+  echo "Directory ${workspacePath} not found. Cloning repository..."
+  ${gitPrefix} git clone --progress --depth 1 --branch ${shellQuote(source.branch)} ${shellQuote(remoteUrl)} ${shellQuote(workspacePath)}
+fi`,
+    {
+      onStdout: options.onLog,
+      onStderr: options.onLog,
+    },
+  );
+  return workspacePath;
+}
+
+module.exports = {
+  deriveSourceName,
+  fingerprintSource,
+  materializeLocalSource,
+  materializeRemoteGitSource,
+  withLocalRepository,
+};