k3s-deployer 0.1.0

package/index.cjs

@@ -0,0 +1 @@
+module.exports = require('./src/index.cjs');

package/index.d.ts

@@ -0,0 +1,193 @@
+export type RepositorySource =
+  | { kind: 'git'; url: string; branch: string; fullName?: string; accessToken?: string }
+  | { kind: 'local'; path: string; branch?: string };
+
+export type DatastoreKind =
+  | 'postgresql'
+  | 'mysql'
+  | 'sqlite'
+  | 'mongodb'
+  | 'redis'
+  | 'elasticsearch';
+
+export type UnitRole = 'backend' | 'frontend' | 'mobile';
+
+export interface InspectionUnit {
+  id: string;
+  role: UnitRole;
+  framework: string;
+  root: string;
+  language: string;
+  port?: number;
+  build: {
+    install: string[];
+    build?: string[];
+    start?: string[];
+    packageManager?: string;
+  };
+}
+
+export interface InspectionResult {
+  projectSlug: string;
+  layout: 'monorepo' | 'single-role';
+  units: InspectionUnit[];
+  datastores: Array<{
+    kind: DatastoreKind;
+    role: 'primary' | 'auxiliary';
+    source: 'config' | 'dependency' | 'env' | 'heuristic';
+  }>;
+  warnings: string[];
+}
+
+export interface DeploymentPlan {
+  inspection: InspectionResult;
+  cluster: {
+    bootstrap: 'if-missing';
+    registryHost: string;
+    namespace: string;
+  };
+  env: {
+    backend: Record<string, string>;
+    frontendPublic: Record<string, string>;
+  };
+  manifests: {
+    apps: string[];
+    data: string[];
+  };
+  mobile?: {
+    framework: 'android' | 'flutter';
+    apkPath: string;
+    applicationId?: string;
+  };
+}
+
+export interface DeployResult {
+  releaseId: string;
+  unitUrls: Record<string, string>;
+  mobilePreviewUrl?: string;
+  mobileArtifactPath?: string;
+  mobileApplicationId?: string;
+  dnsRecord?: {
+    provider: 'cloudflare';
+    type: 'A';
+    domain: string;
+    targetIp: string;
+    proxied: boolean;
+  } | null;
+  logs: string[];
+}
+
+export interface CloudflareDnsConfig {
+  apiToken?: string;
+  apiKey?: string;
+  email?: string;
+  zoneId?: string;
+  targetIp?: string;
+  proxied?: boolean;
+}
+
+export interface DetectOverrides {
+  projectName?: string;
+  backendRoot?: string;
+  frontendRoot?: string;
+  mobileRoot?: string;
+  primaryDatastore?: DatastoreKind;
+}
+
+export interface PlanOverrides extends DetectOverrides {
+  namespace?: string;
+  registryHost?: string;
+  domain?: string;
+  privateEnv?: Record<string, string>;
+  publicEnv?: Record<string, string>;
+  serviceBasePort?: number;
+  deploymentStrategy?: 'rolling-update' | 'blue-green' | 'canary';
+}
+
+export type RuntimeTarget =
+  | { kind: 'local'; workspaceRoot?: string; hostAddress?: string }
+  | {
+      kind: 'ssh';
+      host: string;
+      user: string;
+      port?: number;
+      workspaceRoot?: string;
+      privateKey?: string;
+      privateKeyPath?: string;
+      password?: string;
+      sudoPassword?: string;
+      connectTimeoutSec?: number;
+      commandTimeoutMs?: number;
+      hostAddress?: string;
+    };
+
+export interface ClusterStatus {
+  docker: boolean;
+  k3s: boolean;
+  registry: boolean;
+  ingress: boolean;
+  certManager: boolean;
+  namespace: string;
+  target: 'local' | 'ssh';
+}
+
+export interface MobilePreviewAdapter {
+  start(input: {
+    projectSlug: string;
+    framework: 'android' | 'flutter';
+    artifactPath?: string;
+    applicationId?: string;
+    plan: DeploymentPlan;
+    options?: MobilePreviewOptions;
+  }): Promise<{ url: string }>;
+}
+
+export interface MobilePreviewOptions {
+  artifactPath?: string;
+  installArtifact?: boolean;
+}
+
+export interface SupplementalFile {
+  path: string;
+  contentBase64: string;
+}
+
+export interface DeployOptions {
+  target?: RuntimeTarget;
+  overrides?: PlanOverrides;
+  dryRun?: boolean;
+  onLog?: (line: string) => void | Promise<void>;
+  source?: RepositorySource;
+  workspaceName?: string;
+  supplementalFiles?: SupplementalFile[];
+  cloudflareDns?: CloudflareDnsConfig;
+}
+
+export interface K3sDeployerConfig {
+  workspaceRoot?: string;
+  registryHost?: string;
+  namespacePrefix?: string;
+  mobileBuildTimeoutMs?: number;
+  defaultTarget?: RuntimeTarget;
+  mobilePreviewAdapter?: MobilePreviewAdapter;
+  runnerFactory?: (target: RuntimeTarget) => Promise<unknown> | unknown;
+  cloudflareDns?: CloudflareDnsConfig;
+}
+
+export interface WebAndroidEmulatorAdapterOptions {
+  namespace?: string;
+  domain?: string;
+  registryHost?: string;
+  previewUrl?: string;
+  cloudflareDns?: CloudflareDnsConfig;
+}
+
+export function createWebAndroidEmulatorAdapter(options?: WebAndroidEmulatorAdapterOptions): MobilePreviewAdapter;
+
+export function createK3sDeployer(config?: K3sDeployerConfig): {
+  inspectRepository(source: RepositorySource, overrides?: DetectOverrides): Promise<InspectionResult>;
+  planDeployment(source: RepositorySource, overrides?: PlanOverrides): Promise<DeploymentPlan>;
+  ensureCluster(target: RuntimeTarget): Promise<ClusterStatus>;
+  deploy(source: RepositorySource | DeploymentPlan, options?: DeployOptions): Promise<DeployResult>;
+  startMobilePreview(plan: DeploymentPlan, options?: MobilePreviewOptions): Promise<{ url: string }>;
+};

package/index.mjs

@@ -0,0 +1,4 @@
+import pkg from './index.cjs';
+
+export const createK3sDeployer = pkg.createK3sDeployer;
+export default pkg;

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "k3s-deployer",
+  "version": "0.1.0",
+  "description": "Automatic k3s deployment planner and executor for full stack applications",
+  "main": "./index.cjs",
+  "module": "./index.mjs",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./index.cjs",
+      "import": "./index.mjs",
+      "types": "./index.d.ts"
+    }
+  },
+  "files": [
+    "index.cjs",
+    "index.mjs",
+    "index.d.ts",
+    "src/"
+  ],
+  "scripts": {
+    "test": "node --test",
+    "prepublishOnly": "node --test"
+  },
+  "keywords": [
+    "k3s",
+    "kubernetes",
+    "deploy",
+    "deployment",
+    "docker",
+    "devops",
+    "fullstack"
+  ],
+  "author": "3x-haust",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/3x-haust/k3s-deployer"
+  },
+  "bugs": {
+    "url": "https://github.com/3x-haust/k3s-deployer/issues"
+  },
+  "homepage": "https://github.com/3x-haust/k3s-deployer#readme",
+  "dependencies": {
+    "ssh2": "^1.17.0"
+  },
+  "license": "MIT"
+}

package/src/bootstrap/index.cjs

@@ -0,0 +1,211 @@
+const { createRunner } = require('../runtime/index.cjs');
+const { shellQuote } = require('../shared/utils.cjs');
+
+async function commandSucceeds(runner, command, options = {}) {
+  try {
+    await runner.run(command, { ...options, allowFailure: false });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function getRegistryProbeUrl(registryHost) {
+  const normalized = String(registryHost || 'localhost:5000').replace(/\/+$/, '');
+  if (normalized.startsWith('http://') || normalized.startsWith('https://')) {
+    return `${normalized}/v2/`;
+  }
+  return `http://${normalized}/v2/`;
+}
+
+function getRegistryProbeUrls(registryHost) {
+  const urls = [
+    'http://localhost:5000/v2/',
+    'http://127.0.0.1:5000/v2/',
+    getRegistryProbeUrl(registryHost),
+  ];
+  return Array.from(new Set(urls));
+}
+
+async function findHealthyRegistryProbe(runner, probeUrls, dryRun) {
+  for (const probeUrl of probeUrls) {
+    if (
+      await commandSucceeds(
+        runner,
+        `curl -fsS ${shellQuote(probeUrl)} >/dev/null 2>&1`,
+        { dryRun },
+      )
+    ) {
+      return probeUrl;
+    }
+  }
+  return null;
+}
+
+async function ensureCluster(target, config = {}, options = {}) {
+  const runner = options.runner || (await createRunner(target, config));
+  const namespace = options.namespace || `${config.namespacePrefix || 'apps'}-default`;
+  const dryRun = options.dryRun || false;
+  const log = options.onLog || (() => {});
+  const registryHost = config.registryHost || 'localhost:5000';
+  const registryProbeUrls = getRegistryProbeUrls(registryHost);
+  const runLogged = (command, extra = {}) =>
+    runner.run(command, {
+      dryRun,
+      onStdout: log,
+      onStderr: log,
+      ...extra,
+    });
+
+  const dockerInstalled = await commandSucceeds(runner, 'command -v docker >/dev/null 2>&1', { dryRun });
+  if (!dockerInstalled) {
+    await log('Installing Docker');
+    await runLogged('curl -fsSL https://get.docker.com | sh');
+    await log('Installed Docker');
+  }
+
+  const k3sInstalled = await commandSucceeds(runner, 'command -v k3s >/dev/null 2>&1', { dryRun });
+  if (!k3sInstalled) {
+    await log('Installing k3s');
+    await runLogged(
+      'curl -sfL https://get.k3s.io | sh -s - --write-kubeconfig-mode 644',
+    );
+    await log('Installed k3s');
+  }
+
+  const healthyRegistryProbe = await findHealthyRegistryProbe(
+    runner,
+    registryProbeUrls,
+    dryRun,
+  );
+  if (healthyRegistryProbe) {
+    await log(`Using existing registry at ${healthyRegistryProbe.replace(/\/v2\/$/, '')}`);
+  } else {
+    await log('Starting local registry');
+    try {
+      await runLogged(
+        'docker rm -f k3s-deployer-registry >/dev/null 2>&1 || true && docker run -d -p 5000:5000 --restart always --name k3s-deployer-registry registry:2',
+      );
+      await log('Started local registry');
+    } catch (error) {
+      const registryNowHealthy = await findHealthyRegistryProbe(
+        runner,
+        registryProbeUrls,
+        dryRun,
+      );
+      if (registryNowHealthy) {
+        await log(`Using existing registry at ${registryNowHealthy.replace(/\/v2\/$/, '')}`);
+      } else if (
+        error instanceof Error &&
+        /port is already allocated|address already in use/i.test(error.message)
+      ) {
+        throw new Error(
+          `Port 5000 is already in use on the target host and no registry responded at ${registryProbeUrls.join(', ')}`,
+        );
+      } else {
+        throw error;
+      }
+    }
+  }
+
+  await runLogged(
+    `sudo mkdir -p /etc/docker && sudo python3 - <<'PY'
+import json
+import os
+
+path = '/etc/docker/daemon.json'
+data = {}
+if os.path.exists(path):
+    try:
+        with open(path, 'r', encoding='utf-8') as handle:
+            data = json.load(handle)
+    except Exception:
+        data = {}
+
+registries = data.get('insecure-registries') or []
+for item in ['localhost:5000', '127.0.0.1:5000', '${registryHost}']:
+    if item not in registries:
+        registries.append(item)
+
+data['insecure-registries'] = registries
+with open(path, 'w', encoding='utf-8') as handle:
+    json.dump(data, handle)
+PY`,
+  );
+  await runLogged('sudo systemctl restart docker || sudo service docker restart || true', {
+    allowFailure: true,
+  });
+
+  await runLogged(
+    `sudo mkdir -p /etc/rancher/k3s && sudo sh -lc "cat > /etc/rancher/k3s/registries.yaml <<'EOF'
+mirrors:
+  ${registryHost}:
+    endpoint:
+      - http://${registryHost}
+configs:
+  ${registryHost}:
+    tls:
+      insecure_skip_verify: true
+EOF
+"`,
+    { allowFailure: true },
+  );
+  await runLogged('sudo systemctl restart k3s || sudo service k3s restart || true', {
+    allowFailure: true,
+  });
+  await runLogged('kubectl wait --for=condition=Ready node --all --timeout=120s || kubectl get nodes || true', {
+    allowFailure: true,
+  });
+  await runLogged(`TARGET_NODE=$(hostname)
+if ! kubectl get node "$TARGET_NODE" >/dev/null 2>&1; then
+  TARGET_NODE=$(hostname -s)
+fi
+if [ -n "$TARGET_NODE" ] && kubectl get node "$TARGET_NODE" >/dev/null 2>&1; then
+  kubectl label nodes --all k3s-deployer-target- >/dev/null 2>&1 || true
+  kubectl label node "$TARGET_NODE" k3s-deployer-target=true --overwrite
+fi`, {
+    allowFailure: true,
+  });
+
+  if (namespace !== 'default') {
+    await runLogged(`kubectl get namespace ${shellQuote(namespace)} >/dev/null 2>&1 || kubectl create namespace ${shellQuote(namespace)}`, {
+      allowFailure: true,
+    });
+  }
+
+  const ingressInstalled = await commandSucceeds(runner, 'kubectl get namespace ingress-nginx >/dev/null 2>&1', {
+    dryRun,
+  });
+  if (!ingressInstalled) {
+    await log('Installing ingress-nginx');
+    await runLogged(
+      'kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/main/deploy/static/provider/cloud/deploy.yaml',
+    );
+    await log('Installed ingress-nginx');
+  }
+
+  const certManagerInstalled = await commandSucceeds(runner, 'kubectl get namespace cert-manager >/dev/null 2>&1', {
+    dryRun,
+  });
+  if (!certManagerInstalled) {
+    await log('Installing cert-manager');
+    await runLogged(
+      'kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.15.1/cert-manager.yaml',
+    );
+    await log('Installed cert-manager');
+  }
+
+  return {
+    docker: true,
+    k3s: true,
+    registry: true,
+    ingress: true,
+    certManager: true,
+    namespace,
+    target: target && target.kind === 'ssh' ? 'ssh' : 'local',
+  };
+}
+
+module.exports = {
+  ensureCluster,
+};